<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
<meta http-equiv="X-UA-Compatible" content="IE=9"/>
<meta name="generator" content="Doxygen 1.8.5"/>
<title>Homework Hub: Dbz.HomeworkHub.Frontend/Scripts/knockout.js Quellcode</title>
<link href="tabs.css" rel="stylesheet" type="text/css"/>
<script type="text/javascript" src="jquery.js"></script>
<script type="text/javascript" src="dynsections.js"></script>
<link href="search/search.css" rel="stylesheet" type="text/css"/>
<script type="text/javascript" src="search/search.js"></script>
<script type="text/javascript">
  $(document).ready(function() { searchBox.OnSelectItem(0); });
</script>
<link href="doxygen.css" rel="stylesheet" type="text/css" />
</head>
<body>
<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
<div id="titlearea">
<table cellspacing="0" cellpadding="0">
 <tbody>
 <tr style="height: 56px;">
  <td style="padding-left: 0.5em;">
   <div id="projectname">Homework Hub
   </div>
  </td>
 </tr>
 </tbody>
</table>
</div>
<!-- end header part -->
<!-- Erzeugt von Doxygen 1.8.5 -->
<script type="text/javascript">
var searchBox = new SearchBox("searchBox", "search",false,'Suchen');
</script>
  <div id="navrow1" class="tabs">
    <ul class="tablist">
      <li><a href="index.html"><span>Hauptseite</span></a></li>
      <li><a href="namespaces.html"><span>Pakete</span></a></li>
      <li><a href="annotated.html"><span>Klassen</span></a></li>
      <li class="current"><a href="files.html"><span>Dateien</span></a></li>
      <li>
        <div id="MSearchBox" class="MSearchBoxInactive">
        <span class="left">
          <img id="MSearchSelect" src="search/mag_sel.png"
               onmouseover="return searchBox.OnSearchSelectShow()"
               onmouseout="return searchBox.OnSearchSelectHide()"
               alt=""/>
          <input type="text" id="MSearchField" value="Suchen" accesskey="S"
               onfocus="searchBox.OnSearchFieldFocus(true)" 
               onblur="searchBox.OnSearchFieldFocus(false)" 
               onkeyup="searchBox.OnSearchFieldChange(event)"/>
          </span><span class="right">
            <a id="MSearchClose" href="javascript:searchBox.CloseResultsWindow()"><img id="MSearchCloseImg" border="0" src="search/close.png" alt=""/></a>
          </span>
        </div>
      </li>
    </ul>
  </div>
  <div id="navrow2" class="tabs2">
    <ul class="tablist">
      <li><a href="files.html"><span>Auflistung&#160;der&#160;Dateien</span></a></li>
    </ul>
  </div>
<!-- window showing the filter options -->
<div id="MSearchSelectWindow"
     onmouseover="return searchBox.OnSearchSelectShow()"
     onmouseout="return searchBox.OnSearchSelectHide()"
     onkeydown="return searchBox.OnSearchSelectKey(event)">
<a class="SelectItem" href="javascript:void(0)" onclick="searchBox.OnSelectItem(0)"><span class="SelectionMark">&#160;</span>Alle</a><a class="SelectItem" href="javascript:void(0)" onclick="searchBox.OnSelectItem(1)"><span class="SelectionMark">&#160;</span>Klassen</a><a class="SelectItem" href="javascript:void(0)" onclick="searchBox.OnSelectItem(2)"><span class="SelectionMark">&#160;</span>Namensbereiche</a><a class="SelectItem" href="javascript:void(0)" onclick="searchBox.OnSelectItem(3)"><span class="SelectionMark">&#160;</span>Funktionen</a><a class="SelectItem" href="javascript:void(0)" onclick="searchBox.OnSelectItem(4)"><span class="SelectionMark">&#160;</span>Propertys</a></div>

<!-- iframe showing the search results (closed by default) -->
<div id="MSearchResultsWindow">
<iframe src="javascript:void(0)" frameborder="0" 
        name="MSearchResults" id="MSearchResults">
</iframe>
</div>

<div id="nav-path" class="navpath">
  <ul>
<li class="navelem"><a class="el" href="dir_8ceaaad29b11b58613139a8a4ef8dad7.html">Dbz.HomeworkHub.Frontend</a></li><li class="navelem"><a class="el" href="dir_3f3559871cbcdee78a0dd824c61bab66.html">Scripts</a></li>  </ul>
</div>
</div><!-- top -->
<div class="header">
  <div class="headertitle">
<div class="title">knockout.js</div>  </div>
</div><!--header-->
<div class="contents">
<div class="fragment"><div class="line"><a name="l00001"></a><span class="lineno">    1</span>&#160;<span class="comment">// Knockout JavaScript library v3.0.0</span></div>
<div class="line"><a name="l00002"></a><span class="lineno">    2</span>&#160;<span class="comment">// (c) Steven Sanderson - http://knockoutjs.com/</span></div>
<div class="line"><a name="l00003"></a><span class="lineno">    3</span>&#160;<span class="comment">// License: MIT (http://www.opensource.org/licenses/mit-license.php)</span></div>
<div class="line"><a name="l00004"></a><span class="lineno">    4</span>&#160;</div>
<div class="line"><a name="l00005"></a><span class="lineno">    5</span>&#160;(<span class="keyword">function</span> () {</div>
<div class="line"><a name="l00006"></a><span class="lineno">    6</span>&#160;    (<span class="keyword">function</span> (q) {</div>
<div class="line"><a name="l00007"></a><span class="lineno">    7</span>&#160;        var y = <span class="keyword">this</span> || (0, eval)(<span class="stringliteral">&quot;this&quot;</span>), w = y.document, K = y.navigator, u = y.jQuery, B = y.JSON; (<span class="keyword">function</span> (q) { <span class="stringliteral">&quot;function&quot;</span> === typeof require &amp;&amp; <span class="stringliteral">&quot;object&quot;</span> === typeof exports &amp;&amp; <span class="stringliteral">&quot;object&quot;</span> === typeof module ? q(module.exports || exports) : <span class="stringliteral">&quot;function&quot;</span> === typeof define &amp;&amp; define.amd ? define([<span class="stringliteral">&quot;exports&quot;</span>], q) : q(y.ko = {}) })(<span class="keyword">function</span> (F) {</div>
<div class="line"><a name="l00008"></a><span class="lineno">    8</span>&#160;            <span class="keyword">function</span> G(a, c) { <span class="keywordflow">return</span> null === a || typeof a in N ? a === c : !1 } <span class="keyword">function</span> H(b, c, d, e) {</div>
<div class="line"><a name="l00009"></a><span class="lineno">    9</span>&#160;                a.d[b] = {</div>
<div class="line"><a name="l00010"></a><span class="lineno">   10</span>&#160;                    init: <span class="keyword">function</span> (b) { a.a.f.set(b, L, {}); <span class="keywordflow">return</span> { controlsDescendantBindings: !0 } }, update: <span class="keyword">function</span> (b, h, k, m, f) {</div>
<div class="line"><a name="l00011"></a><span class="lineno">   11</span>&#160;                        k = a.a.f.get(b, L); h = a.a.c(h());</div>
<div class="line"><a name="l00012"></a><span class="lineno">   12</span>&#160;                        m = !d !== !h; var p = !k.ob; <span class="keywordflow">if</span> (p || c || m !== k.Db) p &amp;&amp; (k.ob = a.a.Ya(a.e.childNodes(b), !0)), m ? (p || a.e.S(b, a.a.Ya(k.ob)), a.Ta(e ? e(f, h) : f, b)) : a.e.Z(b), k.Db = m</div>
<div class="line"><a name="l00013"></a><span class="lineno">   13</span>&#160;                    }</div>
<div class="line"><a name="l00014"></a><span class="lineno">   14</span>&#160;                }; a.g.Y[b] = !1; a.e.P[b] = !0</div>
<div class="line"><a name="l00015"></a><span class="lineno">   15</span>&#160;            } var a = <span class="stringliteral">&quot;undefined&quot;</span> !== typeof F ? F : {}; a.b = <span class="keyword">function</span> (b, c) { <span class="keywordflow">for</span> (var d = b.split(<span class="stringliteral">&quot;.&quot;</span>), e = a, g = 0; g &lt; d.length - 1; g++) e = e[d[g]]; e[d[d.length - 1]] = c }; a.s = <span class="keyword">function</span> (a, c, d) { a[c] = d }; a.version = <span class="stringliteral">&quot;3.0.0&quot;</span>; a.b(<span class="stringliteral">&quot;version&quot;</span>, a.version); a.a = <span class="keyword">function</span> () {</div>
<div class="line"><a name="l00016"></a><span class="lineno">   16</span>&#160;                <span class="keyword">function</span> b(a, b) { <span class="keywordflow">for</span> (var f in a) a.hasOwnProperty(f) &amp;&amp; b(f, a[f]) } <span class="keyword">function</span> c(k, b) {</div>
<div class="line"><a name="l00017"></a><span class="lineno">   17</span>&#160;                    <span class="keywordflow">if</span> (<span class="stringliteral">&quot;input&quot;</span> !== a.a.v(k) || !k.type || <span class="stringliteral">&quot;click&quot;</span> !=</div>
<div class="line"><a name="l00018"></a><span class="lineno">   18</span>&#160;                    b.toLowerCase()) <span class="keywordflow">return</span> !1; var f = k.type; <span class="keywordflow">return</span> <span class="stringliteral">&quot;checkbox&quot;</span> == f || <span class="stringliteral">&quot;radio&quot;</span> == f</div>
<div class="line"><a name="l00019"></a><span class="lineno">   19</span>&#160;                } var d = {}, e = {}; d[K &amp;&amp; /Firefox\/2/i.test(K.userAgent) ? <span class="stringliteral">&quot;KeyboardEvent&quot;</span> : <span class="stringliteral">&quot;UIEvents&quot;</span>] = [<span class="stringliteral">&quot;keyup&quot;</span>, <span class="stringliteral">&quot;keydown&quot;</span>, <span class="stringliteral">&quot;keypress&quot;</span>]; d.MouseEvents = <span class="stringliteral">&quot;click dblclick mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave&quot;</span>.split(<span class="stringliteral">&quot; &quot;</span>); b(d, <span class="keyword">function</span> (a, b) { <span class="keywordflow">if</span> (b.length) for (var f = 0, c = b.length; f &lt; c; f++) e[b[f]] = a }); var g = { propertychange: !0 }, h = w &amp;&amp; <span class="keyword">function</span> () {</div>
<div class="line"><a name="l00020"></a><span class="lineno">   20</span>&#160;                    <span class="keywordflow">for</span> (var a = 3, b = w.createElement(<span class="stringliteral">&quot;div&quot;</span>), f = b.getElementsByTagName(<span class="stringliteral">&quot;i&quot;</span>) ; b.innerHTML = <span class="stringliteral">&quot;\x3c!--[if gt IE &quot;</span> +</div>
<div class="line"><a name="l00021"></a><span class="lineno">   21</span>&#160;                    ++a + <span class="stringliteral">&quot;]&gt;&lt;i&gt;&lt;/i&gt;&lt;![endif]--\x3e&quot;</span>, f[0];); <span class="keywordflow">return</span> 4 &lt; a ? a : q</div>
<div class="line"><a name="l00022"></a><span class="lineno">   22</span>&#160;                }(); <span class="keywordflow">return</span> {</div>
<div class="line"><a name="l00023"></a><span class="lineno">   23</span>&#160;                    $a: [<span class="stringliteral">&quot;authenticity_token&quot;</span>, /^__RequestVerificationToken(_.*)?$/], n: <span class="keyword">function</span> (a, b) { <span class="keywordflow">for</span> (var f = 0, c = a.length; f &lt; c; f++) b(a[f]) }, l: <span class="keyword">function</span> (a, b) { <span class="keywordflow">if</span> (<span class="stringliteral">&quot;function&quot;</span> == typeof Array.prototype.indexOf) <span class="keywordflow">return</span> Array.prototype.indexOf.call(a, b); <span class="keywordflow">for</span> (var f = 0, c = a.length; f &lt; c; f++) <span class="keywordflow">if</span> (a[f] === b) <span class="keywordflow">return</span> f; <span class="keywordflow">return</span> -1 }, Ua: <span class="keyword">function</span> (a, b, f) { <span class="keywordflow">for</span> (var c = 0, d = a.length; c &lt; d; c++) <span class="keywordflow">if</span> (b.call(f, a[c])) <span class="keywordflow">return</span> a[c]; <span class="keywordflow">return</span> null }, ia: <span class="keyword">function</span> (b, c) { var f = a.a.l(b, c); 0 &lt;= f &amp;&amp; b.splice(f, 1) }, Va: <span class="keyword">function</span> (b) {</div>
<div class="line"><a name="l00024"></a><span class="lineno">   24</span>&#160;                        b =</div>
<div class="line"><a name="l00025"></a><span class="lineno">   25</span>&#160;                        b || []; <span class="keywordflow">for</span> (var c = [], f = 0, d = b.length; f &lt; d; f++) 0 &gt; a.a.l(c, b[f]) &amp;&amp; c.push(b[f]); <span class="keywordflow">return</span> c</div>
<div class="line"><a name="l00026"></a><span class="lineno">   26</span>&#160;                    }, ha: <span class="keyword">function</span> (a, b) { a = a || []; <span class="keywordflow">for</span> (var f = [], c = 0, d = a.length; c &lt; d; c++) f.push(b(a[c])); <span class="keywordflow">return</span> f }, ga: <span class="keyword">function</span> (a, b) { a = a || []; <span class="keywordflow">for</span> (var f = [], c = 0, d = a.length; c &lt; d; c++) b(a[c]) &amp;&amp; f.push(a[c]); <span class="keywordflow">return</span> f }, X: <span class="keyword">function</span> (a, b) { <span class="keywordflow">if</span> (b instanceof Array) a.push.apply(a, b); <span class="keywordflow">else</span> <span class="keywordflow">for</span> (var f = 0, c = b.length; f &lt; c; f++) a.push(b[f]); <span class="keywordflow">return</span> a }, V: <span class="keyword">function</span> (b, c, f) { var d = a.a.l(a.a.Ha(b), c); 0 &gt; d ? f &amp;&amp; b.push(c) : f || b.splice(d, 1) }, extend: <span class="keyword">function</span> (a, b) {</div>
<div class="line"><a name="l00027"></a><span class="lineno">   27</span>&#160;                        <span class="keywordflow">if</span> (b) <span class="keywordflow">for</span> (var f in b) b.hasOwnProperty(f) &amp;&amp;</div>
<div class="line"><a name="l00028"></a><span class="lineno">   28</span>&#160;                        (a[f] = b[f]); <span class="keywordflow">return</span> a</div>
<div class="line"><a name="l00029"></a><span class="lineno">   29</span>&#160;                    }, K: b, Da: <span class="keyword">function</span> (a, b) { <span class="keywordflow">if</span> (!a) <span class="keywordflow">return</span> a; var f = {}, c; <span class="keywordflow">for</span> (c in a) a.hasOwnProperty(c) &amp;&amp; (f[c] = b(a[c], c, a)); <span class="keywordflow">return</span> f }, wa: <span class="keyword">function</span> (b) { <span class="keywordflow">for</span> (; b.firstChild;) a.removeNode(b.firstChild) }, Vb: <span class="keyword">function</span> (b) { b = a.a.Q(b); <span class="keywordflow">for</span> (var c = w.createElement(<span class="stringliteral">&quot;div&quot;</span>), f = 0, d = b.length; f &lt; d; f++) c.appendChild(a.L(b[f])); <span class="keywordflow">return</span> c }, Ya: <span class="keyword">function</span> (b, c) { <span class="keywordflow">for</span> (var f = 0, d = b.length, e = []; f &lt; d; f++) { var g = b[f].cloneNode(!0); e.push(c ? a.L(g) : g) } <span class="keywordflow">return</span> e }, S: <span class="keyword">function</span> (b, c) { a.a.wa(b); <span class="keywordflow">if</span> (c) <span class="keywordflow">for</span> (var f = 0, d = c.length; f &lt; d; f++) b.appendChild(c[f]) }, nb: <span class="keyword">function</span> (b,</div>
<div class="line"><a name="l00030"></a><span class="lineno">   30</span>&#160;                    c) { var f = b.nodeType ? [b] : b; <span class="keywordflow">if</span> (0 &lt; f.length) { <span class="keywordflow">for</span> (var d = f[0], e = d.parentNode, g = 0, n = c.length; g &lt; n; g++) e.insertBefore(c[g], d); g = 0; <span class="keywordflow">for</span> (n = f.length; g &lt; n; g++) a.removeNode(f[g]) } }, $: <span class="keyword">function</span> (a, b) { <span class="keywordflow">if</span> (a.length) { <span class="keywordflow">for</span> (b = 8 === b.nodeType &amp;&amp; b.parentNode || b; a.length &amp;&amp; a[0].parentNode !== b;) a.splice(0, 1); <span class="keywordflow">if</span> (1 &lt; a.length) { var f = a[0], c = a[a.length - 1]; <span class="keywordflow">for</span> (a.length = 0; f !== c;) <span class="keywordflow">if</span> (a.push(f), f = f.nextSibling, !f) <span class="keywordflow">return</span>; a.push(c) } } <span class="keywordflow">return</span> a }, qb: <span class="keyword">function</span> (a, b) { 7 &gt; h ? a.setAttribute(<span class="stringliteral">&quot;selected&quot;</span>, b) : a.selected = b }, la: <span class="keyword">function</span> (a) {</div>
<div class="line"><a name="l00031"></a><span class="lineno">   31</span>&#160;                        <span class="keywordflow">return</span> null === a || a ===</div>
<div class="line"><a name="l00032"></a><span class="lineno">   32</span>&#160;                        q ? <span class="stringliteral">&quot;&quot;</span> : a.trim ? a.trim() : a.toString().replace(/^[\s\xa0]+|[\s\xa0]+$/g, <span class="stringliteral">&quot;&quot;</span>)</div>
<div class="line"><a name="l00033"></a><span class="lineno">   33</span>&#160;                    }, ec: <span class="keyword">function</span> (b, c) { <span class="keywordflow">for</span> (var f = [], d = (b || <span class="stringliteral">&quot;&quot;</span>).split(c), e = 0, g = d.length; e &lt; g; e++) { var n = a.a.la(d[e]); <span class="stringliteral">&quot;&quot;</span> !== n &amp;&amp; f.push(n) } <span class="keywordflow">return</span> f }, ac: <span class="keyword">function</span> (a, b) { a = a || <span class="stringliteral">&quot;&quot;</span>; <span class="keywordflow">return</span> b.length &gt; a.length ? !1 : a.substring(0, b.length) === b }, Gb: <span class="keyword">function</span> (a, b) {</div>
<div class="line"><a name="l00034"></a><span class="lineno">   34</span>&#160;                        <span class="keywordflow">if</span> (a === b) <span class="keywordflow">return</span> !0; <span class="keywordflow">if</span> (11 === a.nodeType) <span class="keywordflow">return</span> !1; <span class="keywordflow">if</span> (b.contains) <span class="keywordflow">return</span> b.contains(3 === a.nodeType ? a.parentNode : a); <span class="keywordflow">if</span> (b.compareDocumentPosition) <span class="keywordflow">return</span> 16 == (b.compareDocumentPosition(a) &amp; 16); <span class="keywordflow">for</span> (; a &amp;&amp; a != b;) a = a.parentNode;</div>
<div class="line"><a name="l00035"></a><span class="lineno">   35</span>&#160;                        <span class="keywordflow">return</span> !!a</div>
<div class="line"><a name="l00036"></a><span class="lineno">   36</span>&#160;                    }, va: <span class="keyword">function</span> (b) { <span class="keywordflow">return</span> a.a.Gb(b, b.ownerDocument.documentElement) }, Ra: <span class="keyword">function</span> (b) { <span class="keywordflow">return</span> !!a.a.Ua(b, a.a.va) }, v: <span class="keyword">function</span> (a) { <span class="keywordflow">return</span> a &amp;&amp; a.tagName &amp;&amp; a.tagName.toLowerCase() }, r: <span class="keyword">function</span> (b, d, f) {</div>
<div class="line"><a name="l00037"></a><span class="lineno">   37</span>&#160;                        var e = h &amp;&amp; g[d]; <span class="keywordflow">if</span> (e || <span class="stringliteral">&quot;undefined&quot;</span> == typeof u) <span class="keywordflow">if</span> (e || <span class="stringliteral">&quot;function&quot;</span> != typeof b.addEventListener) <span class="keywordflow">if</span> (<span class="stringliteral">&quot;undefined&quot;</span> != typeof b.attachEvent) { var s = <span class="keyword">function</span> (a) { f.call(b, a) }, l = <span class="stringliteral">&quot;on&quot;</span> + d; b.attachEvent(l, s); a.a.C.ea(b, <span class="keyword">function</span> () { b.detachEvent(l, s) }) } <span class="keywordflow">else</span> <span class="keywordflow">throw</span> Error(<span class="stringliteral">&quot;Browser doesn&#39;t support addEventListener or attachEvent&quot;</span>); <span class="keywordflow">else</span> b.addEventListener(d,</div>
<div class="line"><a name="l00038"></a><span class="lineno">   38</span>&#160;                        f, !1); <span class="keywordflow">else</span> { <span class="keywordflow">if</span> (c(b, d)) { var n = f; f = <span class="keyword">function</span> (a, b) { var f = this.checked; b &amp;&amp; (this.checked = !0 !== b.Ab); n.call(<span class="keyword">this</span>, a); this.checked = f } } u(b).bind(d, f) }</div>
<div class="line"><a name="l00039"></a><span class="lineno">   39</span>&#160;                    }, da: <span class="keyword">function</span> (a, b) {</div>
<div class="line"><a name="l00040"></a><span class="lineno">   40</span>&#160;                        <span class="keywordflow">if</span> (!a || !a.nodeType) <span class="keywordflow">throw</span> Error(<span class="stringliteral">&quot;element must be a DOM node when calling triggerEvent&quot;</span>); <span class="keywordflow">if</span> (<span class="stringliteral">&quot;undefined&quot;</span> != typeof u) { var f = []; c(a, b) &amp;&amp; f.push({ Ab: a.checked }); u(a).trigger(b, f) } <span class="keywordflow">else</span> <span class="keywordflow">if</span> (<span class="stringliteral">&quot;function&quot;</span> == typeof w.createEvent) <span class="keywordflow">if</span> (<span class="stringliteral">&quot;function&quot;</span> == typeof a.dispatchEvent) f = w.createEvent(e[b] || <span class="stringliteral">&quot;HTMLEvents&quot;</span>), f.initEvent(b, !0, !0, y, 0, 0, 0, 0, 0, !1, !1, !1, !1, 0, a), a.dispatchEvent(f);</div>
<div class="line"><a name="l00041"></a><span class="lineno">   41</span>&#160;                        <span class="keywordflow">else</span> <span class="keywordflow">throw</span> Error(<span class="stringliteral">&quot;The supplied element doesn&#39;t support dispatchEvent&quot;</span>); <span class="keywordflow">else</span> <span class="keywordflow">if</span> (<span class="stringliteral">&quot;undefined&quot;</span> != typeof a.fireEvent) c(a, b) &amp;&amp; (a.checked = !0 !== a.checked), a.fireEvent(<span class="stringliteral">&quot;on&quot;</span> + b); <span class="keywordflow">else</span> <span class="keywordflow">throw</span> Error(<span class="stringliteral">&quot;Browser doesn&#39;t support triggering events&quot;</span>);</div>
<div class="line"><a name="l00042"></a><span class="lineno">   42</span>&#160;                    }, c: <span class="keyword">function</span> (b) { <span class="keywordflow">return</span> a.M(b) ? b() : b }, Ha: function (b) { <span class="keywordflow">return</span> a.M(b) ? b.t() : b }, ma: <span class="keyword">function</span> (b, c, f) { <span class="keywordflow">if</span> (c) { var d = /\S+/g, e = b.className.match(d) || []; a.a.n(c.match(d), <span class="keyword">function</span> (b) { a.a.V(e, b, f) }); b.className = e.join(<span class="stringliteral">&quot; &quot;</span>) } }, Ma: <span class="keyword">function</span> (b, c) {</div>
<div class="line"><a name="l00043"></a><span class="lineno">   43</span>&#160;                        var f = a.a.c(c); <span class="keywordflow">if</span> (null === f || f === q) f = <span class="stringliteral">&quot;&quot;</span>; var d = a.e.firstChild(b);</div>
<div class="line"><a name="l00044"></a><span class="lineno">   44</span>&#160;                        !d || 3 != d.nodeType || a.e.nextSibling(d) ? a.e.S(b, [w.createTextNode(f)]) : d.data = f; a.a.Jb(b)</div>
<div class="line"><a name="l00045"></a><span class="lineno">   45</span>&#160;                    }, pb: <span class="keyword">function</span> (a, b) { a.name = b; <span class="keywordflow">if</span> (7 &gt;= h) <span class="keywordflow">try</span> { a.mergeAttributes(w.createElement(<span class="stringliteral">&quot;&lt;input name=&#39;&quot;</span> + a.name + <span class="stringliteral">&quot;&#39;/&gt;&quot;</span>), !1) } <span class="keywordflow">catch</span> (f) { } }, Jb: <span class="keyword">function</span> (a) { 9 &lt;= h &amp;&amp; (a = 1 == a.nodeType ? a : a.parentNode, a.style &amp;&amp; (a.style.zoom = a.style.zoom)) }, Hb: <span class="keyword">function</span> (a) { <span class="keywordflow">if</span> (h) { var b = a.style.width; a.style.width = 0; a.style.width = b } }, Zb: <span class="keyword">function</span> (b, c) { b = a.a.c(b); c = a.a.c(c); <span class="keywordflow">for</span> (var f = [], d = b; d &lt;= c; d++) f.push(d); <span class="keywordflow">return</span> f }, Q: <span class="keyword">function</span> (a) {</div>
<div class="line"><a name="l00046"></a><span class="lineno">   46</span>&#160;                        <span class="keywordflow">for</span> (var b = [], c = 0, d = a.length; c &lt;</div>
<div class="line"><a name="l00047"></a><span class="lineno">   47</span>&#160;                        d; c++) b.push(a[c]); <span class="keywordflow">return</span> b</div>
<div class="line"><a name="l00048"></a><span class="lineno">   48</span>&#160;                    }, cc: 6 === h, dc: 7 === h, ja: h, ab: <span class="keyword">function</span> (b, c) { <span class="keywordflow">for</span> (var f = a.a.Q(b.getElementsByTagName(<span class="stringliteral">&quot;input&quot;</span>)).concat(a.a.Q(b.getElementsByTagName(<span class="stringliteral">&quot;textarea&quot;</span>))), d = <span class="stringliteral">&quot;string&quot;</span> == typeof c ? <span class="keyword">function</span> (a) { <span class="keywordflow">return</span> a.name === c } : <span class="keyword">function</span> (a) { <span class="keywordflow">return</span> c.test(a.name) }, e = [], g = f.length - 1; 0 &lt;= g; g--) d(f[g]) &amp;&amp; e.push(f[g]); <span class="keywordflow">return</span> e }, Wb: <span class="keyword">function</span> (b) { <span class="keywordflow">return</span> <span class="stringliteral">&quot;string&quot;</span> == typeof b &amp;&amp; (b = a.a.la(b)) ? B &amp;&amp; B.parse ? B.parse(b) : (<span class="keyword">new</span> Function(<span class="stringliteral">&quot;return &quot;</span> + b))() : null }, Na: <span class="keyword">function</span> (b, c, f) {</div>
<div class="line"><a name="l00049"></a><span class="lineno">   49</span>&#160;                        <span class="keywordflow">if</span> (!B || !B.stringify) <span class="keywordflow">throw</span> Error(<span class="stringliteral">&quot;Cannot find JSON.stringify(). Some browsers (e.g., IE &lt; 8) don&#39;t support it natively, but you can overcome this by adding a script reference to json2.js, downloadable from http://www.json.org/json2.js&quot;</span>);</div>
<div class="line"><a name="l00050"></a><span class="lineno">   50</span>&#160;                        <span class="keywordflow">return</span> B.stringify(a.a.c(b), c, f)</div>
<div class="line"><a name="l00051"></a><span class="lineno">   51</span>&#160;                    }, Xb: <span class="keyword">function</span> (c, d, f) {</div>
<div class="line"><a name="l00052"></a><span class="lineno">   52</span>&#160;                        f = f || {}; var e = f.params || {}, g = f.includeFields || this.$a, h = c; <span class="keywordflow">if</span> (<span class="stringliteral">&quot;object&quot;</span> == typeof c &amp;&amp; <span class="stringliteral">&quot;form&quot;</span> === a.a.v(c)) <span class="keywordflow">for</span> (var h = c.action, n = g.length - 1; 0 &lt;= n; n--) <span class="keywordflow">for</span> (var r = a.a.ab(c, g[n]), v = r.length - 1; 0 &lt;= v; v--) e[r[v].name] = r[v].value; d = a.a.c(d); var t = w.createElement(<span class="stringliteral">&quot;form&quot;</span>); t.style.display = <span class="stringliteral">&quot;none&quot;</span>; t.action = h; t.method = <span class="stringliteral">&quot;post&quot;</span>; <span class="keywordflow">for</span> (var E in d) c = w.createElement(<span class="stringliteral">&quot;input&quot;</span>), c.name = E, c.value = a.a.Na(a.a.c(d[E])), t.appendChild(c); b(e, <span class="keyword">function</span> (a, b) {</div>
<div class="line"><a name="l00053"></a><span class="lineno">   53</span>&#160;                            var c = w.createElement(<span class="stringliteral">&quot;input&quot;</span>); c.name =</div>
<div class="line"><a name="l00054"></a><span class="lineno">   54</span>&#160;                            a; c.value = b; t.appendChild(c)</div>
<div class="line"><a name="l00055"></a><span class="lineno">   55</span>&#160;                        }); w.body.appendChild(t); f.submitter ? f.submitter(t) : t.submit(); setTimeout(<span class="keyword">function</span> () { t.parentNode.removeChild(t) }, 0)</div>
<div class="line"><a name="l00056"></a><span class="lineno">   56</span>&#160;                    }</div>
<div class="line"><a name="l00057"></a><span class="lineno">   57</span>&#160;                }</div>
<div class="line"><a name="l00058"></a><span class="lineno">   58</span>&#160;            }(); a.b(<span class="stringliteral">&quot;utils&quot;</span>, a.a); a.b(<span class="stringliteral">&quot;utils.arrayForEach&quot;</span>, a.a.n); a.b(<span class="stringliteral">&quot;utils.arrayFirst&quot;</span>, a.a.Ua); a.b(<span class="stringliteral">&quot;utils.arrayFilter&quot;</span>, a.a.ga); a.b(<span class="stringliteral">&quot;utils.arrayGetDistinctValues&quot;</span>, a.a.Va); a.b(<span class="stringliteral">&quot;utils.arrayIndexOf&quot;</span>, a.a.l); a.b(<span class="stringliteral">&quot;utils.arrayMap&quot;</span>, a.a.ha); a.b(<span class="stringliteral">&quot;utils.arrayPushAll&quot;</span>, a.a.X); a.b(<span class="stringliteral">&quot;utils.arrayRemoveItem&quot;</span>, a.a.ia); a.b(<span class="stringliteral">&quot;utils.extend&quot;</span>, a.a.extend); a.b(<span class="stringliteral">&quot;utils.fieldsIncludedWithJsonPost&quot;</span>,</div>
<div class="line"><a name="l00059"></a><span class="lineno">   59</span>&#160;            a.a.$a); a.b(<span class="stringliteral">&quot;utils.getFormFields&quot;</span>, a.a.ab); a.b(<span class="stringliteral">&quot;utils.peekObservable&quot;</span>, a.a.Ha); a.b(<span class="stringliteral">&quot;utils.postJson&quot;</span>, a.a.Xb); a.b(<span class="stringliteral">&quot;utils.parseJson&quot;</span>, a.a.Wb); a.b(<span class="stringliteral">&quot;utils.registerEventHandler&quot;</span>, a.a.r); a.b(<span class="stringliteral">&quot;utils.stringifyJson&quot;</span>, a.a.Na); a.b(<span class="stringliteral">&quot;utils.range&quot;</span>, a.a.Zb); a.b(<span class="stringliteral">&quot;utils.toggleDomNodeCssClass&quot;</span>, a.a.ma); a.b(<span class="stringliteral">&quot;utils.triggerEvent&quot;</span>, a.a.da); a.b(<span class="stringliteral">&quot;utils.unwrapObservable&quot;</span>, a.a.c); a.b(<span class="stringliteral">&quot;utils.objectForEach&quot;</span>, a.a.K); a.b(<span class="stringliteral">&quot;utils.addOrRemoveItem&quot;</span>, a.a.V); a.b(<span class="stringliteral">&quot;unwrap&quot;</span>, a.a.c); Function.prototype.bind || (Function.prototype.bind = <span class="keyword">function</span> (a) {</div>
<div class="line"><a name="l00060"></a><span class="lineno">   60</span>&#160;                var c =</div>
<div class="line"><a name="l00061"></a><span class="lineno">   61</span>&#160;                <span class="keyword">this</span>, d = Array.prototype.slice.call(arguments); a = d.shift(); <span class="keywordflow">return</span> <span class="keyword">function</span> () { <span class="keywordflow">return</span> c.apply(a, d.concat(Array.prototype.slice.call(arguments))) }</div>
<div class="line"><a name="l00062"></a><span class="lineno">   62</span>&#160;            }); a.a.f = <span class="keyword">new</span> <span class="keyword">function</span> () {</div>
<div class="line"><a name="l00063"></a><span class="lineno">   63</span>&#160;                <span class="keyword">function</span> a(b, h) { var k = b[d]; <span class="keywordflow">if</span> (!k || <span class="stringliteral">&quot;null&quot;</span> === k || !e[k]) { <span class="keywordflow">if</span> (!h) <span class="keywordflow">return</span> q; k = b[d] = <span class="stringliteral">&quot;ko&quot;</span> + c++; e[k] = {} } <span class="keywordflow">return</span> e[k] } var c = 0, d = <span class="stringliteral">&quot;__ko__&quot;</span> + (<span class="keyword">new</span> Date).getTime(), e = {}; <span class="keywordflow">return</span> {</div>
<div class="line"><a name="l00064"></a><span class="lineno">   64</span>&#160;                    <span class="keyword">get</span>: <span class="keyword">function</span> (c, d) { var e = a(c, !1); <span class="keywordflow">return</span> e === q ? q : e[d] }, set: <span class="keyword">function</span> (c, d, e) { <span class="keywordflow">if</span> (e !== q || a(c, !1) !== q) a(c, !0)[d] = e }, clear: <span class="keyword">function</span> (a) { var b = a[d]; <span class="keywordflow">return</span> b ? (<span class="keyword">delete</span> e[b], a[d] = null, !0) : !1 }, D: <span class="keyword">function</span> () {</div>
<div class="line"><a name="l00065"></a><span class="lineno">   65</span>&#160;                        <span class="keywordflow">return</span> c++ +</div>
<div class="line"><a name="l00066"></a><span class="lineno">   66</span>&#160;                        d</div>
<div class="line"><a name="l00067"></a><span class="lineno">   67</span>&#160;                    }</div>
<div class="line"><a name="l00068"></a><span class="lineno">   68</span>&#160;                }</div>
<div class="line"><a name="l00069"></a><span class="lineno">   69</span>&#160;            }; a.b(<span class="stringliteral">&quot;utils.domData&quot;</span>, a.a.f); a.b(<span class="stringliteral">&quot;utils.domData.clear&quot;</span>, a.a.f.clear); a.a.C = <span class="keyword">new</span> <span class="keyword">function</span> () {</div>
<div class="line"><a name="l00070"></a><span class="lineno">   70</span>&#160;                <span class="keyword">function</span> b(b, c) { var e = a.a.f.get(b, d); e === q &amp;&amp; c &amp;&amp; (e = [], a.a.f.set(b, d, e)); <span class="keywordflow">return</span> e } <span class="keyword">function</span> c(d) { var e = b(d, !1); <span class="keywordflow">if</span> (e) <span class="keywordflow">for</span> (var e = e.slice(0), m = 0; m &lt; e.length; m++) e[m](d); a.a.f.clear(d); <span class="stringliteral">&quot;function&quot;</span> == typeof u &amp;&amp; <span class="stringliteral">&quot;function&quot;</span> == typeof u.cleanData &amp;&amp; u.cleanData([d]); <span class="keywordflow">if</span> (g[d.nodeType]) <span class="keywordflow">for</span> (e = d.firstChild; d = e;) e = d.nextSibling, 8 === d.nodeType &amp;&amp; c(d) } var d = a.a.f.D(), e = { 1: !0, 8: !0, 9: !0 }, g = { 1: !0, 9: !0 }; <span class="keywordflow">return</span> {</div>
<div class="line"><a name="l00071"></a><span class="lineno">   71</span>&#160;                    ea: <span class="keyword">function</span> (a, c) {</div>
<div class="line"><a name="l00072"></a><span class="lineno">   72</span>&#160;                        <span class="keywordflow">if</span> (<span class="stringliteral">&quot;function&quot;</span> !=</div>
<div class="line"><a name="l00073"></a><span class="lineno">   73</span>&#160;                        typeof c) <span class="keywordflow">throw</span> Error(<span class="stringliteral">&quot;Callback must be a function&quot;</span>); b(a, !0).push(c)</div>
<div class="line"><a name="l00074"></a><span class="lineno">   74</span>&#160;                    }, mb: <span class="keyword">function</span> (c, e) { var g = b(c, !1); g &amp;&amp; (a.a.ia(g, e), 0 == g.length &amp;&amp; a.a.f.set(c, d, q)) }, L: <span class="keyword">function</span> (b) { <span class="keywordflow">if</span> (e[b.nodeType] &amp;&amp; (c(b), g[b.nodeType])) { var d = []; a.a.X(d, b.getElementsByTagName(<span class="stringliteral">&quot;*&quot;</span>)); <span class="keywordflow">for</span> (var m = 0, f = d.length; m &lt; f; m++) c(d[m]) } <span class="keywordflow">return</span> b }, removeNode: <span class="keyword">function</span> (b) { a.L(b); b.parentNode &amp;&amp; b.parentNode.removeChild(b) }</div>
<div class="line"><a name="l00075"></a><span class="lineno">   75</span>&#160;                }</div>
<div class="line"><a name="l00076"></a><span class="lineno">   76</span>&#160;            }; a.L = a.a.C.L; a.removeNode = a.a.C.removeNode; a.b(<span class="stringliteral">&quot;cleanNode&quot;</span>, a.L); a.b(<span class="stringliteral">&quot;removeNode&quot;</span>, a.removeNode); a.b(<span class="stringliteral">&quot;utils.domNodeDisposal&quot;</span>, a.a.C);</div>
<div class="line"><a name="l00077"></a><span class="lineno">   77</span>&#160;            a.b(<span class="stringliteral">&quot;utils.domNodeDisposal.addDisposeCallback&quot;</span>, a.a.C.ea); a.b(<span class="stringliteral">&quot;utils.domNodeDisposal.removeDisposeCallback&quot;</span>, a.a.C.mb); (<span class="keyword">function</span> () {</div>
<div class="line"><a name="l00078"></a><span class="lineno">   78</span>&#160;                a.a.Fa = <span class="keyword">function</span> (b) {</div>
<div class="line"><a name="l00079"></a><span class="lineno">   79</span>&#160;                    var c; <span class="keywordflow">if</span> (<span class="stringliteral">&quot;undefined&quot;</span> != typeof u) <span class="keywordflow">if</span> (u.parseHTML) c = u.parseHTML(b) || []; <span class="keywordflow">else</span> { <span class="keywordflow">if</span> ((c = u.clean([b])) &amp;&amp; c[0]) { <span class="keywordflow">for</span> (b = c[0]; b.parentNode &amp;&amp; 11 !== b.parentNode.nodeType;) b = b.parentNode; b.parentNode &amp;&amp; b.parentNode.removeChild(b) } } <span class="keywordflow">else</span> {</div>
<div class="line"><a name="l00080"></a><span class="lineno">   80</span>&#160;                        var d = a.a.la(b).toLowerCase(); c = w.createElement(<span class="stringliteral">&quot;div&quot;</span>); d = d.match(/^&lt;(thead|tbody|tfoot)/) &amp;&amp; [1, <span class="stringliteral">&quot;&lt;table&gt;&quot;</span>, <span class="stringliteral">&quot;&lt;/table&gt;&quot;</span>] || !d.indexOf(<span class="stringliteral">&quot;&lt;tr&quot;</span>) &amp;&amp; [2,</div>
<div class="line"><a name="l00081"></a><span class="lineno">   81</span>&#160;                        <span class="stringliteral">&quot;&lt;table&gt;&lt;tbody&gt;&quot;</span>, <span class="stringliteral">&quot;&lt;/tbody&gt;&lt;/table&gt;&quot;</span>] || (!d.indexOf(<span class="stringliteral">&quot;&lt;td&quot;</span>) || !d.indexOf(<span class="stringliteral">&quot;&lt;th&quot;</span>)) &amp;&amp; [3, <span class="stringliteral">&quot;&lt;table&gt;&lt;tbody&gt;&lt;tr&gt;&quot;</span>, <span class="stringliteral">&quot;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;&quot;</span>] || [0, <span class="stringliteral">&quot;&quot;</span>, <span class="stringliteral">&quot;&quot;</span>]; b = <span class="stringliteral">&quot;ignored&lt;div&gt;&quot;</span> + d[1] + b + d[2] + <span class="stringliteral">&quot;&lt;/div&gt;&quot;</span>; <span class="keywordflow">for</span> (<span class="stringliteral">&quot;function&quot;</span> == typeof y.innerShiv ? c.appendChild(y.innerShiv(b)) : c.innerHTML = b; d[0]--;) c = c.lastChild; c = a.a.Q(c.lastChild.childNodes)</div>
<div class="line"><a name="l00082"></a><span class="lineno">   82</span>&#160;                    } <span class="keywordflow">return</span> c</div>
<div class="line"><a name="l00083"></a><span class="lineno">   83</span>&#160;                }; a.a.Ka = <span class="keyword">function</span> (b, c) { a.a.wa(b); c = a.a.c(c); <span class="keywordflow">if</span> (null !== c &amp;&amp; c !== q) <span class="keywordflow">if</span> (<span class="stringliteral">&quot;string&quot;</span> != typeof c &amp;&amp; (c = c.toString()), <span class="stringliteral">&quot;undefined&quot;</span> != typeof u) u(b).html(c); <span class="keywordflow">else</span> <span class="keywordflow">for</span> (var d = a.a.Fa(c), e = 0; e &lt; d.length; e++) b.appendChild(d[e]) }</div>
<div class="line"><a name="l00084"></a><span class="lineno">   84</span>&#160;            })();</div>
<div class="line"><a name="l00085"></a><span class="lineno">   85</span>&#160;            a.b(<span class="stringliteral">&quot;utils.parseHtmlFragment&quot;</span>, a.a.Fa); a.b(<span class="stringliteral">&quot;utils.setHtml&quot;</span>, a.a.Ka); a.u = <span class="keyword">function</span> () {</div>
<div class="line"><a name="l00086"></a><span class="lineno">   86</span>&#160;                <span class="keyword">function</span> b(c, e) { <span class="keywordflow">if</span> (c) <span class="keywordflow">if</span> (8 == c.nodeType) { var g = a.u.jb(c.nodeValue); null != g &amp;&amp; e.push({ Fb: c, Tb: g }) } <span class="keywordflow">else</span> <span class="keywordflow">if</span> (1 == c.nodeType) <span class="keywordflow">for</span> (var g = 0, h = c.childNodes, k = h.length; g &lt; k; g++) b(h[g], e) } var c = {}; <span class="keywordflow">return</span> {</div>
<div class="line"><a name="l00087"></a><span class="lineno">   87</span>&#160;                    Ca: <span class="keyword">function</span> (a) {</div>
<div class="line"><a name="l00088"></a><span class="lineno">   88</span>&#160;                        <span class="keywordflow">if</span> (<span class="stringliteral">&quot;function&quot;</span> != typeof a) <span class="keywordflow">throw</span> Error(<span class="stringliteral">&quot;You can only pass a function to ko.memoization.memoize()&quot;</span>); var b = (4294967296 * (1 + Math.random()) | 0).toString(16).substring(1) + (4294967296 * (1 + Math.random()) | 0).toString(16).substring(1);</div>
<div class="line"><a name="l00089"></a><span class="lineno">   89</span>&#160;                        c[b] = a; <span class="keywordflow">return</span> <span class="stringliteral">&quot;\x3c!--[ko_memo:&quot;</span> + b + <span class="stringliteral">&quot;]--\x3e&quot;</span></div>
<div class="line"><a name="l00090"></a><span class="lineno">   90</span>&#160;                    }, ub: <span class="keyword">function</span> (a, b) { var g = c[a]; <span class="keywordflow">if</span> (g === q) <span class="keywordflow">throw</span> Error(<span class="stringliteral">&quot;Couldn&#39;t find any memo with ID &quot;</span> + a + <span class="stringliteral">&quot;. Perhaps it&#39;s already been unmemoized.&quot;</span>); <span class="keywordflow">try</span> { <span class="keywordflow">return</span> g.apply(null, b || []), !0 } <span class="keywordflow">finally</span> { <span class="keyword">delete</span> c[a] } }, vb: <span class="keyword">function</span> (c, e) { var g = []; b(c, g); <span class="keywordflow">for</span> (var h = 0, k = g.length; h &lt; k; h++) { var m = g[h].Fb, f = [m]; e &amp;&amp; a.a.X(f, e); a.u.ub(g[h].Tb, f); m.nodeValue = <span class="stringliteral">&quot;&quot;</span>; m.parentNode &amp;&amp; m.parentNode.removeChild(m) } }, jb: <span class="keyword">function</span> (a) { <span class="keywordflow">return</span> (a = a.match(/^\[ko_memo\:(.*?)\]$/)) ? a[1] : null }</div>
<div class="line"><a name="l00091"></a><span class="lineno">   91</span>&#160;                }</div>
<div class="line"><a name="l00092"></a><span class="lineno">   92</span>&#160;            }(); a.b(<span class="stringliteral">&quot;memoization&quot;</span>, a.u); a.b(<span class="stringliteral">&quot;memoization.memoize&quot;</span>,</div>
<div class="line"><a name="l00093"></a><span class="lineno">   93</span>&#160;            a.u.Ca); a.b(<span class="stringliteral">&quot;memoization.unmemoize&quot;</span>, a.u.ub); a.b(<span class="stringliteral">&quot;memoization.parseMemoText&quot;</span>, a.u.jb); a.b(<span class="stringliteral">&quot;memoization.unmemoizeDomNodeAndDescendants&quot;</span>, a.u.vb); a.xa = { throttle: <span class="keyword">function</span> (b, c) { b.throttleEvaluation = c; var d = null; <span class="keywordflow">return</span> a.h({ read: b, write: <span class="keyword">function</span> (a) { clearTimeout(d); d = setTimeout(<span class="keyword">function</span> () { b(a) }, c) } }) }, notify: <span class="keyword">function</span> (a, c) { a.equalityComparer = <span class="stringliteral">&quot;always&quot;</span> == c ? null : G } }; var N = { undefined: 1, <span class="stringliteral">&quot;boolean&quot;</span>: 1, number: 1, <span class="keywordtype">string</span>: 1 }; a.b(<span class="stringliteral">&quot;extenders&quot;</span>, a.xa); a.sb = <span class="keyword">function</span> (b, c, d) {</div>
<div class="line"><a name="l00094"></a><span class="lineno">   94</span>&#160;                this.target = b; this.qa = c; this.Eb = d; a.s(<span class="keyword">this</span>, <span class="stringliteral">&quot;dispose&quot;</span>,</div>
<div class="line"><a name="l00095"></a><span class="lineno">   95</span>&#160;                this.B)</div>
<div class="line"><a name="l00096"></a><span class="lineno">   96</span>&#160;            }; a.sb.prototype.B = <span class="keyword">function</span> () { this.Qb = !0; this.Eb() }; a.ca = <span class="keyword">function</span> () { this.F = {}; a.a.extend(<span class="keyword">this</span>, a.ca.fn); a.s(<span class="keyword">this</span>, <span class="stringliteral">&quot;subscribe&quot;</span>, this.T); a.s(<span class="keyword">this</span>, <span class="stringliteral">&quot;extend&quot;</span>, this.extend); a.s(<span class="keyword">this</span>, <span class="stringliteral">&quot;getSubscriptionsCount&quot;</span>, this.Lb) }; var I = <span class="stringliteral">&quot;change&quot;</span>; a.ca.fn = {</div>
<div class="line"><a name="l00097"></a><span class="lineno">   97</span>&#160;                T: <span class="keyword">function</span> (b, c, d) { d = d || I; var e = <span class="keyword">new</span> a.sb(<span class="keyword">this</span>, c ? b.bind(c) : b, <span class="keyword">function</span> () { a.a.ia(this.F[d], e) }.bind(<span class="keyword">this</span>)); this.F[d] || (this.F[d] = []); this.F[d].push(e); <span class="keywordflow">return</span> e }, notifySubscribers: <span class="keyword">function</span> (b, c) {</div>
<div class="line"><a name="l00098"></a><span class="lineno">   98</span>&#160;                    c = c || I; <span class="keywordflow">if</span> (this.cb(c)) <span class="keywordflow">try</span> {</div>
<div class="line"><a name="l00099"></a><span class="lineno">   99</span>&#160;                        a.i.Wa(); <span class="keywordflow">for</span> (var d = this.F[c].slice(0), e = 0, g; g = d[e]; ++e) g &amp;&amp;</div>
<div class="line"><a name="l00100"></a><span class="lineno">  100</span>&#160;                        !0 !== g.Qb &amp;&amp; g.qa(b)</div>
<div class="line"><a name="l00101"></a><span class="lineno">  101</span>&#160;                    } <span class="keywordflow">finally</span> { a.i.end() }</div>
<div class="line"><a name="l00102"></a><span class="lineno">  102</span>&#160;                }, cb: <span class="keyword">function</span> (a) { <span class="keywordflow">return</span> this.F[a] &amp;&amp; this.F[a].length }, Lb: <span class="keyword">function</span> () { var b = 0; a.a.K(this.F, <span class="keyword">function</span> (a, d) { b += d.length }); <span class="keywordflow">return</span> b }, extend: <span class="keyword">function</span> (b) { var c = <span class="keyword">this</span>; b &amp;&amp; a.a.K(b, <span class="keyword">function</span> (b, e) { var g = a.xa[b]; <span class="stringliteral">&quot;function&quot;</span> == typeof g &amp;&amp; (c = g(c, e) || c) }); <span class="keywordflow">return</span> c }</div>
<div class="line"><a name="l00103"></a><span class="lineno">  103</span>&#160;            }; a.fb = <span class="keyword">function</span> (a) { <span class="keywordflow">return</span> null != a &amp;&amp; <span class="stringliteral">&quot;function&quot;</span> == typeof a.T &amp;&amp; <span class="stringliteral">&quot;function&quot;</span> == typeof a.notifySubscribers }; a.b(<span class="stringliteral">&quot;subscribable&quot;</span>, a.ca); a.b(<span class="stringliteral">&quot;isSubscribable&quot;</span>, a.fb); a.i = <span class="keyword">function</span> () {</div>
<div class="line"><a name="l00104"></a><span class="lineno">  104</span>&#160;                var b = []; <span class="keywordflow">return</span> {</div>
<div class="line"><a name="l00105"></a><span class="lineno">  105</span>&#160;                    Wa: <span class="keyword">function</span> (a) { b.push(a &amp;&amp; { qa: a, Za: [] }) },</div>
<div class="line"><a name="l00106"></a><span class="lineno">  106</span>&#160;                    end: <span class="keyword">function</span> () { b.pop() }, lb: <span class="keyword">function</span> (c) { <span class="keywordflow">if</span> (!a.fb(c)) <span class="keywordflow">throw</span> Error(<span class="stringliteral">&quot;Only subscribable things can act as dependencies&quot;</span>); <span class="keywordflow">if</span> (0 &lt; b.length) { var d = b[b.length - 1]; !d || 0 &lt;= a.a.l(d.Za, c) || (d.Za.push(c), d.qa(c)) } }, p: <span class="keyword">function</span> (a, d, e) { <span class="keywordflow">try</span> { <span class="keywordflow">return</span> b.push(null), a.apply(d, e || []) } <span class="keywordflow">finally</span> { b.pop() } }</div>
<div class="line"><a name="l00107"></a><span class="lineno">  107</span>&#160;                }</div>
<div class="line"><a name="l00108"></a><span class="lineno">  108</span>&#160;            }(); a.q = <span class="keyword">function</span> (b) {</div>
<div class="line"><a name="l00109"></a><span class="lineno">  109</span>&#160;                <span class="keyword">function</span> c() { <span class="keywordflow">if</span> (0 &lt; arguments.length) <span class="keywordflow">return</span> c.equalityComparer &amp;&amp; c.equalityComparer(d, arguments[0]) || (c.O(), d = arguments[0], c.N()), <span class="keyword">this</span>; a.i.lb(c); <span class="keywordflow">return</span> d } var d = b; a.ca.call(c); c.t = <span class="keyword">function</span> () { <span class="keywordflow">return</span> d }; c.N = <span class="keyword">function</span> () { c.notifySubscribers(d) };</div>
<div class="line"><a name="l00110"></a><span class="lineno">  110</span>&#160;                c.O = <span class="keyword">function</span> () { c.notifySubscribers(d, <span class="stringliteral">&quot;beforeChange&quot;</span>) }; a.a.extend(c, a.q.fn); a.s(c, <span class="stringliteral">&quot;peek&quot;</span>, c.t); a.s(c, <span class="stringliteral">&quot;valueHasMutated&quot;</span>, c.N); a.s(c, <span class="stringliteral">&quot;valueWillMutate&quot;</span>, c.O); <span class="keywordflow">return</span> c</div>
<div class="line"><a name="l00111"></a><span class="lineno">  111</span>&#160;            }; a.q.fn = { equalityComparer: G }; var C = a.q.Yb = <span class="stringliteral">&quot;__ko_proto__&quot;</span>; a.q.fn[C] = a.q; a.ya = <span class="keyword">function</span> (b, c) { <span class="keywordflow">return</span> null === b || b === q || b[C] === q ? !1 : b[C] === c ? !0 : a.ya(b[C], c) }; a.M = <span class="keyword">function</span> (b) { <span class="keywordflow">return</span> a.ya(b, a.q) }; a.gb = <span class="keyword">function</span> (b) { <span class="keywordflow">return</span> <span class="stringliteral">&quot;function&quot;</span> == typeof b &amp;&amp; b[C] === a.q || <span class="stringliteral">&quot;function&quot;</span> == typeof b &amp;&amp; b[C] === a.h &amp;&amp; b.Nb ? !0 : !1 }; a.b(<span class="stringliteral">&quot;observable&quot;</span>, a.q); a.b(<span class="stringliteral">&quot;isObservable&quot;</span>, a.M); a.b(<span class="stringliteral">&quot;isWriteableObservable&quot;</span>,</div>
<div class="line"><a name="l00112"></a><span class="lineno">  112</span>&#160;            a.gb); a.ba = <span class="keyword">function</span> (b) { b = b || []; <span class="keywordflow">if</span> (<span class="stringliteral">&quot;object&quot;</span> != typeof b || !(<span class="stringliteral">&quot;length&quot;</span> in b)) <span class="keywordflow">throw</span> Error(<span class="stringliteral">&quot;The argument passed when initializing an observable array must be an array, or null, or undefined.&quot;</span>); b = a.q(b); a.a.extend(b, a.ba.fn); <span class="keywordflow">return</span> b.extend({ trackArrayChanges: !0 }) }; a.ba.fn = {</div>
<div class="line"><a name="l00113"></a><span class="lineno">  113</span>&#160;                <span class="keyword">remove</span>: <span class="keyword">function</span> (b) { <span class="keywordflow">for</span> (var c = this.t(), d = [], e = <span class="stringliteral">&quot;function&quot;</span> != typeof b || a.M(b) ? <span class="keyword">function</span> (a) { <span class="keywordflow">return</span> a === b } : b, g = 0; g &lt; c.length; g++) { var h = c[g]; e(h) &amp;&amp; (0 === d.length &amp;&amp; this.O(), d.push(h), c.splice(g, 1), g--) } d.length &amp;&amp; <span class="keyword">this</span>.N(); <span class="keywordflow">return</span> d }, removeAll: <span class="keyword">function</span> (b) {</div>
<div class="line"><a name="l00114"></a><span class="lineno">  114</span>&#160;                    <span class="keywordflow">if</span> (b ===</div>
<div class="line"><a name="l00115"></a><span class="lineno">  115</span>&#160;                    q) { var c = this.t(), d = c.slice(0); this.O(); c.splice(0, c.length); this.N(); <span class="keywordflow">return</span> d } <span class="keywordflow">return</span> b ? this.<span class="keyword">remove</span>(<span class="keyword">function</span> (c) { <span class="keywordflow">return</span> 0 &lt;= a.a.l(b, c) }) : []</div>
<div class="line"><a name="l00116"></a><span class="lineno">  116</span>&#160;                }, destroy: <span class="keyword">function</span> (b) { var c = this.t(), d = <span class="stringliteral">&quot;function&quot;</span> != typeof b || a.M(b) ? <span class="keyword">function</span> (a) { <span class="keywordflow">return</span> a === b } : b; this.O(); <span class="keywordflow">for</span> (var e = c.length - 1; 0 &lt;= e; e--) d(c[e]) &amp;&amp; (c[e]._destroy = !0); this.N() }, destroyAll: <span class="keyword">function</span> (b) { <span class="keywordflow">return</span> b === q ? this.destroy(<span class="keyword">function</span> () { <span class="keywordflow">return</span> !0 }) : b ? this.destroy(<span class="keyword">function</span> (c) { <span class="keywordflow">return</span> 0 &lt;= a.a.l(b, c) }) : [] }, indexOf: <span class="keyword">function</span> (b) { var c = <span class="keyword">this</span>(); <span class="keywordflow">return</span> a.a.l(c, b) }, replace: <span class="keyword">function</span> (a,</div>
<div class="line"><a name="l00117"></a><span class="lineno">  117</span>&#160;                c) { var d = this.indexOf(a); 0 &lt;= d &amp;&amp; (this.O(), this.t()[d] = c, this.N()) }</div>
<div class="line"><a name="l00118"></a><span class="lineno">  118</span>&#160;            }; a.a.n(<span class="stringliteral">&quot;pop push reverse shift sort splice unshift&quot;</span>.split(<span class="stringliteral">&quot; &quot;</span>), <span class="keyword">function</span> (b) { a.ba.fn[b] = <span class="keyword">function</span> () { var a = this.t(); this.O(); this.Xa(a, b, arguments); a = a[b].apply(a, arguments); this.N(); <span class="keywordflow">return</span> a } }); a.a.n([<span class="stringliteral">&quot;slice&quot;</span>], <span class="keyword">function</span> (b) { a.ba.fn[b] = <span class="keyword">function</span> () { var a = <span class="keyword">this</span>(); <span class="keywordflow">return</span> a[b].apply(a, arguments) } }); a.b(<span class="stringliteral">&quot;observableArray&quot;</span>, a.ba); var J = <span class="stringliteral">&quot;arrayChange&quot;</span>; a.xa.trackArrayChanges = <span class="keyword">function</span> (b) {</div>
<div class="line"><a name="l00119"></a><span class="lineno">  119</span>&#160;                <span class="keyword">function</span> c() {</div>
<div class="line"><a name="l00120"></a><span class="lineno">  120</span>&#160;                    <span class="keywordflow">if</span> (!d) {</div>
<div class="line"><a name="l00121"></a><span class="lineno">  121</span>&#160;                        d = !0; var c = b.notifySubscribers; b.notifySubscribers =</div>
<div class="line"><a name="l00122"></a><span class="lineno">  122</span>&#160;                        <span class="keyword">function</span> (a, b) { b &amp;&amp; b !== I || ++g; <span class="keywordflow">return</span> c.apply(<span class="keyword">this</span>, arguments) }; var m = [].concat(b.t() || []); e = null; b.T(<span class="keyword">function</span> (c) { c = [].concat(c || []); <span class="keywordflow">if</span> (b.cb(J)) { var d; <span class="keywordflow">if</span> (!e || 1 &lt; g) e = a.a.ra(m, c, { sparse: !0 }); d = e; d.length &amp;&amp; b.notifySubscribers(d, J) } m = c; e = null; g = 0 })</div>
<div class="line"><a name="l00123"></a><span class="lineno">  123</span>&#160;                    }</div>
<div class="line"><a name="l00124"></a><span class="lineno">  124</span>&#160;                } <span class="keywordflow">if</span> (!b.Xa) {</div>
<div class="line"><a name="l00125"></a><span class="lineno">  125</span>&#160;                    var d = !1, e = null, g = 0, h = b.T; b.T = b.subscribe = <span class="keyword">function</span> (a, b, f) { f === J &amp;&amp; c(); <span class="keywordflow">return</span> h.apply(<span class="keyword">this</span>, arguments) }; b.Xa = <span class="keyword">function</span> (a, b, c) {</div>
<div class="line"><a name="l00126"></a><span class="lineno">  126</span>&#160;                        <span class="keyword">function</span> p(a, b, c) { h.push({ status: a, value: b, index: c }) } <span class="keywordflow">if</span> (d &amp;&amp; !g) {</div>
<div class="line"><a name="l00127"></a><span class="lineno">  127</span>&#160;                            var h = [], l = a.length, n = c.length, r = 0; <span class="keywordflow">switch</span> (b) {</div>
<div class="line"><a name="l00128"></a><span class="lineno">  128</span>&#160;                                <span class="keywordflow">case</span> <span class="stringliteral">&quot;push&quot;</span>: r = l; <span class="keywordflow">case</span> <span class="stringliteral">&quot;unshift&quot;</span>: <span class="keywordflow">for</span> (b =</div>
<div class="line"><a name="l00129"></a><span class="lineno">  129</span>&#160;                                0; b &lt; n; b++) p(<span class="stringliteral">&quot;added&quot;</span>, c[b], r + b); <span class="keywordflow">break</span>; <span class="keywordflow">case</span> <span class="stringliteral">&quot;pop&quot;</span>: r = l - 1; <span class="keywordflow">case</span> <span class="stringliteral">&quot;shift&quot;</span>: l &amp;&amp; p(<span class="stringliteral">&quot;deleted&quot;</span>, a[r], r); <span class="keywordflow">break</span>; <span class="keywordflow">case</span> <span class="stringliteral">&quot;splice&quot;</span>: b = Math.min(Math.max(0, 0 &gt; c[0] ? l + c[0] : c[0]), l); <span class="keywordflow">for</span> (var l = 1 === n ? l : Math.min(b + (c[1] || 0), l), n = b + n - 2, r = Math.max(l, n), v = 2; b &lt; r; ++b, ++v) b &lt; l &amp;&amp; p(<span class="stringliteral">&quot;deleted&quot;</span>, a[b], b), b &lt; n &amp;&amp; p(<span class="stringliteral">&quot;added&quot;</span>, c[v], b); <span class="keywordflow">break</span>; <span class="keywordflow">default</span>: <span class="keywordflow">return</span></div>
<div class="line"><a name="l00130"></a><span class="lineno">  130</span>&#160;                            } e = h</div>
<div class="line"><a name="l00131"></a><span class="lineno">  131</span>&#160;                        }</div>
<div class="line"><a name="l00132"></a><span class="lineno">  132</span>&#160;                    }</div>
<div class="line"><a name="l00133"></a><span class="lineno">  133</span>&#160;                }</div>
<div class="line"><a name="l00134"></a><span class="lineno">  134</span>&#160;            }; a.h = <span class="keyword">function</span> (b, c, d) {</div>
<div class="line"><a name="l00135"></a><span class="lineno">  135</span>&#160;                <span class="keyword">function</span> e() { a.a.n(z, <span class="keyword">function</span> (a) { a.B() }); z = [] } <span class="keyword">function</span> g() { var a = k.throttleEvaluation; a &amp;&amp; 0 &lt;= a ? (clearTimeout(x), x = setTimeout(h, a)) : h() } <span class="keyword">function</span> h() {</div>
<div class="line"><a name="l00136"></a><span class="lineno">  136</span>&#160;                    <span class="keywordflow">if</span> (!s) {</div>
<div class="line"><a name="l00137"></a><span class="lineno">  137</span>&#160;                        <span class="keywordflow">if</span> (E &amp;&amp; E()) {</div>
<div class="line"><a name="l00138"></a><span class="lineno">  138</span>&#160;                            <span class="keywordflow">if</span> (!l) {</div>
<div class="line"><a name="l00139"></a><span class="lineno">  139</span>&#160;                                D();</div>
<div class="line"><a name="l00140"></a><span class="lineno">  140</span>&#160;                                p = !0; <span class="keywordflow">return</span></div>
<div class="line"><a name="l00141"></a><span class="lineno">  141</span>&#160;                            }</div>
<div class="line"><a name="l00142"></a><span class="lineno">  142</span>&#160;                        } <span class="keywordflow">else</span> l = !1; s = !0; <span class="keywordflow">try</span> { var b = a.a.ha(z, <span class="keyword">function</span> (a) { <span class="keywordflow">return</span> a.target }); a.i.Wa(<span class="keyword">function</span> (c) { var d; 0 &lt;= (d = a.a.l(b, c)) ? b[d] = q : z.push(c.T(g)) }); <span class="keywordflow">for</span> (var d = c ? n.call(c) : n(), e = b.length - 1; 0 &lt;= e; e--) b[e] &amp;&amp; z.splice(e, 1)[0].B(); p = !0; k.equalityComparer &amp;&amp; k.equalityComparer(f, d) || (k.notifySubscribers(f, <span class="stringliteral">&quot;beforeChange&quot;</span>), f = d, k.notifySubscribers(f)) } <span class="keywordflow">finally</span> { a.i.end(), s = !1 } z.length || D()</div>
<div class="line"><a name="l00143"></a><span class="lineno">  143</span>&#160;                    }</div>
<div class="line"><a name="l00144"></a><span class="lineno">  144</span>&#160;                } <span class="keyword">function</span> k() {</div>
<div class="line"><a name="l00145"></a><span class="lineno">  145</span>&#160;                    <span class="keywordflow">if</span> (0 &lt; arguments.length) {</div>
<div class="line"><a name="l00146"></a><span class="lineno">  146</span>&#160;                        <span class="keywordflow">if</span> (<span class="stringliteral">&quot;function&quot;</span> === typeof r) r.apply(c, arguments); <span class="keywordflow">else</span> <span class="keywordflow">throw</span> Error(<span class="stringliteral">&quot;Cannot write a value to a ko.computed unless you specify a &#39;write&#39; option. If you wish to read the current value, don&#39;t pass any parameters.&quot;</span>);</div>
<div class="line"><a name="l00147"></a><span class="lineno">  147</span>&#160;                        <span class="keywordflow">return</span> <span class="keyword">this</span></div>
<div class="line"><a name="l00148"></a><span class="lineno">  148</span>&#160;                    } p || h(); a.i.lb(k); <span class="keywordflow">return</span> f</div>
<div class="line"><a name="l00149"></a><span class="lineno">  149</span>&#160;                } <span class="keyword">function</span> m() { <span class="keywordflow">return</span> !p || 0 &lt; z.length } var f, p = !1, s = !1, l = !1, n = b; n &amp;&amp; <span class="stringliteral">&quot;object&quot;</span> == typeof n ? (d = n, n = d.read) : (d = d || {}, n || (n = d.read)); <span class="keywordflow">if</span> (<span class="stringliteral">&quot;function&quot;</span> != typeof n) <span class="keywordflow">throw</span> Error(<span class="stringliteral">&quot;Pass a function that returns the value of the ko.computed&quot;</span>); var r = d.write, v = d.disposeWhenNodeIsRemoved || d.I || null, t = d.disposeWhen || d.ua, E = t, D = e, z = [], x = null; c || (c = d.owner); k.t = <span class="keyword">function</span> () { p || h(); <span class="keywordflow">return</span> f }; k.Kb = <span class="keyword">function</span> () { <span class="keywordflow">return</span> z.length }; k.Nb = <span class="stringliteral">&quot;function&quot;</span> === typeof d.write; k.B = <span class="keyword">function</span> () { D() }; k.aa = m; a.ca.call(k);</div>
<div class="line"><a name="l00150"></a><span class="lineno">  150</span>&#160;                a.a.extend(k, a.h.fn); a.s(k, <span class="stringliteral">&quot;peek&quot;</span>, k.t); a.s(k, <span class="stringliteral">&quot;dispose&quot;</span>, k.B); a.s(k, <span class="stringliteral">&quot;isActive&quot;</span>, k.aa); a.s(k, <span class="stringliteral">&quot;getDependenciesCount&quot;</span>, k.Kb); v &amp;&amp; (l = !0, v.nodeType &amp;&amp; (E = <span class="keyword">function</span> () { <span class="keywordflow">return</span> !a.a.va(v) || t &amp;&amp; t() })); !0 !== d.deferEvaluation &amp;&amp; h(); v &amp;&amp; m() &amp;&amp; (D = <span class="keyword">function</span> () { a.a.C.mb(v, D); e() }, a.a.C.ea(v, D)); <span class="keywordflow">return</span> k</div>
<div class="line"><a name="l00151"></a><span class="lineno">  151</span>&#160;            }; a.Pb = <span class="keyword">function</span> (b) { <span class="keywordflow">return</span> a.ya(b, a.h) }; F = a.q.Yb; a.h[F] = a.q; a.h.fn = { equalityComparer: G }; a.h.fn[F] = a.h; a.b(<span class="stringliteral">&quot;dependentObservable&quot;</span>, a.h); a.b(<span class="stringliteral">&quot;computed&quot;</span>, a.h); a.b(<span class="stringliteral">&quot;isComputed&quot;</span>, a.Pb); (<span class="keyword">function</span> () {</div>
<div class="line"><a name="l00152"></a><span class="lineno">  152</span>&#160;                <span class="keyword">function</span> b(a, g, h) {</div>
<div class="line"><a name="l00153"></a><span class="lineno">  153</span>&#160;                    h = h || <span class="keyword">new</span> d; a = g(a); <span class="keywordflow">if</span> (<span class="stringliteral">&quot;object&quot;</span> !=</div>
<div class="line"><a name="l00154"></a><span class="lineno">  154</span>&#160;                    typeof a || null === a || a === q || a instanceof Date || a instanceof String || a instanceof Number || a instanceof Boolean) <span class="keywordflow">return</span> a; var k = a instanceof Array ? [] : {}; h.save(a, k); c(a, <span class="keyword">function</span> (c) { var d = g(a[c]); <span class="keywordflow">switch</span> (typeof d) { <span class="keywordflow">case</span> <span class="stringliteral">&quot;boolean&quot;</span>: <span class="keywordflow">case</span> <span class="stringliteral">&quot;number&quot;</span>: <span class="keywordflow">case</span> <span class="stringliteral">&quot;string&quot;</span>: <span class="keywordflow">case</span> <span class="stringliteral">&quot;function&quot;</span>: k[c] = d; <span class="keywordflow">break</span>; <span class="keywordflow">case</span> <span class="stringliteral">&quot;object&quot;</span>: <span class="keywordflow">case</span> <span class="stringliteral">&quot;undefined&quot;</span>: var p = h.get(d); k[c] = p !== q ? p : b(d, g, h) } }); <span class="keywordflow">return</span> k</div>
<div class="line"><a name="l00155"></a><span class="lineno">  155</span>&#160;                } <span class="keyword">function</span> c(a, b) { <span class="keywordflow">if</span> (a instanceof Array) { <span class="keywordflow">for</span> (var c = 0; c &lt; a.length; c++) b(c); <span class="stringliteral">&quot;function&quot;</span> == typeof a.toJSON &amp;&amp; b(<span class="stringliteral">&quot;toJSON&quot;</span>) } <span class="keywordflow">else</span> <span class="keywordflow">for</span> (c in a) b(c) } <span class="keyword">function</span> d() {</div>
<div class="line"><a name="l00156"></a><span class="lineno">  156</span>&#160;                    this.keys =</div>
<div class="line"><a name="l00157"></a><span class="lineno">  157</span>&#160;                    []; this.Qa = []</div>
<div class="line"><a name="l00158"></a><span class="lineno">  158</span>&#160;                } a.tb = <span class="keyword">function</span> (c) { <span class="keywordflow">if</span> (0 == arguments.length) <span class="keywordflow">throw</span> Error(<span class="stringliteral">&quot;When calling ko.toJS, pass the object you want to convert.&quot;</span>); <span class="keywordflow">return</span> b(c, <span class="keyword">function</span> (b) { <span class="keywordflow">for</span> (var c = 0; a.M(b) &amp;&amp; 10 &gt; c; c++) b = b(); <span class="keywordflow">return</span> b }) }; a.toJSON = <span class="keyword">function</span> (b, c, d) { b = a.tb(b); <span class="keywordflow">return</span> a.a.Na(b, c, d) }; d.prototype = { save: <span class="keyword">function</span> (b, c) { var d = a.a.l(this.keys, b); 0 &lt;= d ? this.Qa[d] = c : (this.keys.push(b), this.Qa.push(c)) }, <span class="keyword">get</span>: <span class="keyword">function</span> (b) { b = a.a.l(this.keys, b); <span class="keywordflow">return</span> 0 &lt;= b ? this.Qa[b] : q } }</div>
<div class="line"><a name="l00159"></a><span class="lineno">  159</span>&#160;            })(); a.b(<span class="stringliteral">&quot;toJS&quot;</span>, a.tb); a.b(<span class="stringliteral">&quot;toJSON&quot;</span>, a.toJSON); (<span class="keyword">function</span> () {</div>
<div class="line"><a name="l00160"></a><span class="lineno">  160</span>&#160;                a.k = {</div>
<div class="line"><a name="l00161"></a><span class="lineno">  161</span>&#160;                    o: <span class="keyword">function</span> (b) {</div>
<div class="line"><a name="l00162"></a><span class="lineno">  162</span>&#160;                        <span class="keywordflow">switch</span> (a.a.v(b)) {</div>
<div class="line"><a name="l00163"></a><span class="lineno">  163</span>&#160;                            <span class="keywordflow">case</span> <span class="stringliteral">&quot;option&quot;</span>: <span class="keywordflow">return</span> !0 ===</div>
<div class="line"><a name="l00164"></a><span class="lineno">  164</span>&#160;                            b.__ko__hasDomDataOptionValue__ ? a.a.f.get(b, a.d.options.Ea) : 7 &gt;= a.a.ja ? b.getAttributeNode(<span class="stringliteral">&quot;value&quot;</span>) &amp;&amp; b.getAttributeNode(<span class="stringliteral">&quot;value&quot;</span>).specified ? b.value : b.text : b.value; <span class="keywordflow">case</span> <span class="stringliteral">&quot;select&quot;</span>: <span class="keywordflow">return</span> 0 &lt;= b.selectedIndex ? a.k.o(b.options[b.selectedIndex]) : q; <span class="keywordflow">default</span>: <span class="keywordflow">return</span> b.value</div>
<div class="line"><a name="l00165"></a><span class="lineno">  165</span>&#160;                        }</div>
<div class="line"><a name="l00166"></a><span class="lineno">  166</span>&#160;                    }, na: <span class="keyword">function</span> (b, c) {</div>
<div class="line"><a name="l00167"></a><span class="lineno">  167</span>&#160;                        <span class="keywordflow">switch</span> (a.a.v(b)) {</div>
<div class="line"><a name="l00168"></a><span class="lineno">  168</span>&#160;                            <span class="keywordflow">case</span> <span class="stringliteral">&quot;option&quot;</span>: <span class="keywordflow">switch</span> (typeof c) {</div>
<div class="line"><a name="l00169"></a><span class="lineno">  169</span>&#160;                                <span class="keywordflow">case</span> <span class="stringliteral">&quot;string&quot;</span>: a.a.f.set(b, a.d.options.Ea, q); <span class="stringliteral">&quot;__ko__hasDomDataOptionValue__&quot;</span> in b &amp;&amp; <span class="keyword">delete</span> b.__ko__hasDomDataOptionValue__; b.value = c; <span class="keywordflow">break</span>; <span class="keywordflow">default</span>: a.a.f.set(b, a.d.options.Ea, c), b.__ko__hasDomDataOptionValue__ =</div>
<div class="line"><a name="l00170"></a><span class="lineno">  170</span>&#160;                                !0, b.value = <span class="stringliteral">&quot;number&quot;</span> === typeof c ? c : <span class="stringliteral">&quot;&quot;</span></div>
<div class="line"><a name="l00171"></a><span class="lineno">  171</span>&#160;                            } <span class="keywordflow">break</span>; <span class="keywordflow">case</span> <span class="stringliteral">&quot;select&quot;</span>: <span class="stringliteral">&quot;&quot;</span> === c &amp;&amp; (c = q); <span class="keywordflow">if</span> (null === c || c === q) b.selectedIndex = -1; <span class="keywordflow">for</span> (var d = b.options.length - 1; 0 &lt;= d; d--) <span class="keywordflow">if</span> (a.k.o(b.options[d]) == c) { b.selectedIndex = d; <span class="keywordflow">break</span> } 1 &lt; b.size || -1 !== b.selectedIndex || (b.selectedIndex = 0); <span class="keywordflow">break</span>; <span class="keywordflow">default</span>: <span class="keywordflow">if</span> (null === c || c === q) c = <span class="stringliteral">&quot;&quot;</span>; b.value = c</div>
<div class="line"><a name="l00172"></a><span class="lineno">  172</span>&#160;                        }</div>
<div class="line"><a name="l00173"></a><span class="lineno">  173</span>&#160;                    }</div>
<div class="line"><a name="l00174"></a><span class="lineno">  174</span>&#160;                }</div>
<div class="line"><a name="l00175"></a><span class="lineno">  175</span>&#160;            })(); a.b(<span class="stringliteral">&quot;selectExtensions&quot;</span>, a.k); a.b(<span class="stringliteral">&quot;selectExtensions.readValue&quot;</span>, a.k.o); a.b(<span class="stringliteral">&quot;selectExtensions.writeValue&quot;</span>, a.k.na); a.g = <span class="keyword">function</span> () {</div>
<div class="line"><a name="l00176"></a><span class="lineno">  176</span>&#160;                <span class="keyword">function</span> b(b) {</div>
<div class="line"><a name="l00177"></a><span class="lineno">  177</span>&#160;                    b = a.a.la(b); 123 === b.charCodeAt(0) &amp;&amp; (b = b.slice(1, -1)); var c =</div>
<div class="line"><a name="l00178"></a><span class="lineno">  178</span>&#160;                    [], d = b.match(e), k, l, n = 0; <span class="keywordflow">if</span> (d) { d.push(<span class="stringliteral">&quot;,&quot;</span>); <span class="keywordflow">for</span> (var r = 0, v; v = d[r]; ++r) { var t = v.charCodeAt(0); <span class="keywordflow">if</span> (44 === t) { <span class="keywordflow">if</span> (0 &gt;= n) { k &amp;&amp; c.push(l ? { key: k, value: l.join(<span class="stringliteral">&quot;&quot;</span>) } : { unknown: k }); k = l = n = 0; <span class="keywordflow">continue</span> } } <span class="keywordflow">else</span> <span class="keywordflow">if</span> (58 === t) { <span class="keywordflow">if</span> (!l) <span class="keywordflow">continue</span> } <span class="keywordflow">else</span> <span class="keywordflow">if</span> (47 === t &amp;&amp; r &amp;&amp; 1 &lt; v.length) (t = d[r - 1].match(g)) &amp;&amp; !h[t[0]] &amp;&amp; (b = b.substr(b.indexOf(v) + 1), d = b.match(e), d.push(<span class="stringliteral">&quot;,&quot;</span>), r = -1, v = <span class="stringliteral">&quot;/&quot;</span>); <span class="keywordflow">else</span> <span class="keywordflow">if</span> (40 === t || 123 === t || 91 === t)++n; <span class="keywordflow">else</span> <span class="keywordflow">if</span> (41 === t || 125 === t || 93 === t)--n; <span class="keywordflow">else</span> <span class="keywordflow">if</span> (!k &amp;&amp; !l) { k = 34 === t || 39 === t ? v.slice(1, -1) : v; <span class="keywordflow">continue</span> } l ? l.push(v) : l = [v] } } <span class="keywordflow">return</span> c</div>
<div class="line"><a name="l00179"></a><span class="lineno">  179</span>&#160;                } var c = [<span class="stringliteral">&quot;true&quot;</span>,</div>
<div class="line"><a name="l00180"></a><span class="lineno">  180</span>&#160;                <span class="stringliteral">&quot;false&quot;</span>, <span class="stringliteral">&quot;null&quot;</span>, <span class="stringliteral">&quot;undefined&quot;</span>], d = /^(?:[$_a-z][$\w]*|(.+)(\.\s*[$_a-z][$\w]*|\[.+\]))$/i, e = RegExp(<span class="stringliteral">&quot;\&quot;(?:[^\&quot;\\\\]|\\\\.)*\&quot;|&#39;(?:[^&#39;\\\\]|\\\\.)*&#39;|/(?:[^/\\\\]|\\\\.)*/w*|[^\\s:,/][^,\&quot;&#39;{}()/:[\\]]*[^\\s,\&quot;&#39;{}()/:[\\]]|[^\\s]&quot;</span>, <span class="stringliteral">&quot;g&quot;</span>), g = /[\])<span class="stringliteral">&quot;&#39;A-Za-z0-9_$]+$/, h = { &quot;</span>in<span class="stringliteral">&quot;: 1, &quot;</span><span class="keywordflow">return</span><span class="stringliteral">&quot;: 1, &quot;</span>typeof<span class="stringliteral">&quot;: 1 }, k = {}; return {</span></div>
<div class="line"><a name="l00181"></a><span class="lineno">  181</span>&#160;<span class="stringliteral">                    Y: [], U: k, Ga: b, ka: function (e, f) {</span></div>
<div class="line"><a name="l00182"></a><span class="lineno">  182</span>&#160;<span class="stringliteral">                        function g(b, f) {</span></div>
<div class="line"><a name="l00183"></a><span class="lineno">  183</span>&#160;<span class="stringliteral">                            var e, r = a.getBindingHandler(b); if (r &amp;&amp; r.preprocess ? f = r.preprocess(f, b, g) : 1) {</span></div>
<div class="line"><a name="l00184"></a><span class="lineno">  184</span>&#160;<span class="stringliteral">                                if (r = k[b]) e = f, 0 &lt;= a.a.l(c, e) ? e = !1 : (r = e.match(d), e = null === r ? !1 : r[1] ? &quot;</span>Object(<span class="stringliteral">&quot; + r[1] + &quot;</span>)<span class="stringliteral">&quot; +</span></div>
<div class="line"><a name="l00185"></a><span class="lineno">  185</span>&#160;<span class="stringliteral">                                r[2] : e), r = e; r &amp;&amp; l.push(&quot;</span><span class="stringliteral">&#39;&quot; + b + &quot;&#39;</span>:<span class="keyword">function</span>(_z){<span class="stringliteral">&quot; + e + &quot;</span>=_z}<span class="stringliteral">&quot;); n &amp;&amp; (f = &quot;</span><span class="keyword">function</span>(){<span class="keywordflow">return</span> <span class="stringliteral">&quot; + f + &quot;</span> }<span class="stringliteral">&quot;); h.push(&quot;</span><span class="stringliteral">&#39;&quot; + b + &quot;&#39;</span>:<span class="stringliteral">&quot; + f)</span></div>
<div class="line"><a name="l00186"></a><span class="lineno">  186</span>&#160;<span class="stringliteral">                            }</span></div>
<div class="line"><a name="l00187"></a><span class="lineno">  187</span>&#160;<span class="stringliteral">                        } f = f || {}; var h = [], l = [], n = f.valueAccessors, r = &quot;</span><span class="keywordtype">string</span><span class="stringliteral">&quot; === typeof e ? b(e) : e; a.a.n(r, function (a) { g(a.key || a.unknown, a.value) }); l.length &amp;&amp; g(&quot;</span>_ko_property_writers<span class="stringliteral">&quot;, &quot;</span>{<span class="stringliteral">&quot; + l.join(&quot;</span>,<span class="stringliteral">&quot;) + &quot;</span>}<span class="stringliteral">&quot;); return h.join(&quot;</span>,<span class="stringliteral">&quot;)</span></div>
<div class="line"><a name="l00188"></a><span class="lineno">  188</span>&#160;<span class="stringliteral">                    }, Sb: function (a, b) { for (var c = 0; c &lt; a.length; c++) if (a[c].key == b) return !0; return !1 }, oa: function (b, c, d, e, k) { if (b &amp;&amp; a.M(b)) !a.gb(b) || k &amp;&amp; b.t() === e || b(e); else if ((b = c.get(&quot;</span>_ko_property_writers<span class="stringliteral">&quot;)) &amp;&amp; b[d]) b[d](e) }</span></div>
<div class="line"><a name="l00189"></a><span class="lineno">  189</span>&#160;<span class="stringliteral">                }</span></div>
<div class="line"><a name="l00190"></a><span class="lineno">  190</span>&#160;<span class="stringliteral">            }();</span></div>
<div class="line"><a name="l00191"></a><span class="lineno">  191</span>&#160;<span class="stringliteral">            a.b(&quot;</span>expressionRewriting<span class="stringliteral">&quot;, a.g); a.b(&quot;</span>expressionRewriting.bindingRewriteValidators<span class="stringliteral">&quot;, a.g.Y); a.b(&quot;</span>expressionRewriting.parseObjectLiteral<span class="stringliteral">&quot;, a.g.Ga); a.b(&quot;</span>expressionRewriting.preProcessBindings<span class="stringliteral">&quot;, a.g.ka); a.b(&quot;</span>expressionRewriting._twoWayBindings<span class="stringliteral">&quot;, a.g.U); a.b(&quot;</span>jsonExpressionRewriting<span class="stringliteral">&quot;, a.g); a.b(&quot;</span>jsonExpressionRewriting.insertPropertyAccessorsIntoJson<span class="stringliteral">&quot;, a.g.ka); (function () {</span></div>
<div class="line"><a name="l00192"></a><span class="lineno">  192</span>&#160;<span class="stringliteral">                function b(a) { return 8 == a.nodeType &amp;&amp; h.test(g ? a.text : a.nodeValue) } function c(a) { return 8 == a.nodeType &amp;&amp; k.test(g ? a.text : a.nodeValue) } function d(a,</span></div>
<div class="line"><a name="l00193"></a><span class="lineno">  193</span>&#160;<span class="stringliteral">                d) { for (var e = a, k = 1, n = []; e = e.nextSibling;) { if (c(e) &amp;&amp; (k--, 0 === k)) return n; n.push(e); b(e) &amp;&amp; k++ } if (!d) throw Error(&quot;</span>Cannot find closing comment tag to match: <span class="stringliteral">&quot; + a.nodeValue); return null } function e(a, b) { var c = d(a, b); return c ? 0 &lt; c.length ? c[c.length - 1].nextSibling : a.nextSibling : null } var g = w &amp;&amp; &quot;</span>\x3c!--test--\x3e<span class="stringliteral">&quot; === w.createComment(&quot;</span>test<span class="stringliteral">&quot;).text, h = g ? /^\x3c!--\s*ko(?:\s+([\s\S]+))?\s*--\x3e$/ : /^\s*ko(?:\s+([\s\S]+))?\s*$/, k = g ? /^\x3c!--\s*\/ko\s*--\x3e$/ : /^\s*\/ko\s*$/, m = { ul: !0, ol: !0 }; a.e = {</span></div>
<div class="line"><a name="l00194"></a><span class="lineno">  194</span>&#160;<span class="stringliteral">                    P: {}, childNodes: function (a) {</span></div>
<div class="line"><a name="l00195"></a><span class="lineno">  195</span>&#160;<span class="stringliteral">                        return b(a) ?</span></div>
<div class="line"><a name="l00196"></a><span class="lineno">  196</span>&#160;<span class="stringliteral">                        d(a) : a.childNodes</span></div>
<div class="line"><a name="l00197"></a><span class="lineno">  197</span>&#160;<span class="stringliteral">                    }, Z: function (c) { if (b(c)) { c = a.e.childNodes(c); for (var d = 0, e = c.length; d &lt; e; d++) a.removeNode(c[d]) } else a.a.wa(c) }, S: function (c, d) { if (b(c)) { a.e.Z(c); for (var e = c.nextSibling, k = 0, n = d.length; k &lt; n; k++) e.parentNode.insertBefore(d[k], e) } else a.a.S(c, d) }, kb: function (a, c) { b(a) ? a.parentNode.insertBefore(c, a.nextSibling) : a.firstChild ? a.insertBefore(c, a.firstChild) : a.appendChild(c) }, eb: function (c, d, e) {</span></div>
<div class="line"><a name="l00198"></a><span class="lineno">  198</span>&#160;<span class="stringliteral">                        e ? b(c) ? c.parentNode.insertBefore(d, e.nextSibling) : e.nextSibling ? c.insertBefore(d, e.nextSibling) :</span></div>
<div class="line"><a name="l00199"></a><span class="lineno">  199</span>&#160;<span class="stringliteral">                        c.appendChild(d) : a.e.kb(c, d)</span></div>
<div class="line"><a name="l00200"></a><span class="lineno">  200</span>&#160;<span class="stringliteral">                    }, firstChild: function (a) { return b(a) ? !a.nextSibling || c(a.nextSibling) ? null : a.nextSibling : a.firstChild }, nextSibling: function (a) { b(a) &amp;&amp; (a = e(a)); return a.nextSibling &amp;&amp; c(a.nextSibling) ? null : a.nextSibling }, Mb: b, bc: function (a) { return (a = (g ? a.text : a.nodeValue).match(h)) ? a[1] : null }, ib: function (d) {</span></div>
<div class="line"><a name="l00201"></a><span class="lineno">  201</span>&#160;<span class="stringliteral">                        if (m[a.a.v(d)]) {</span></div>
<div class="line"><a name="l00202"></a><span class="lineno">  202</span>&#160;<span class="stringliteral">                            var k = d.firstChild; if (k) {</span></div>
<div class="line"><a name="l00203"></a><span class="lineno">  203</span>&#160;<span class="stringliteral">                                do if (1 === k.nodeType) {</span></div>
<div class="line"><a name="l00204"></a><span class="lineno">  204</span>&#160;<span class="stringliteral">                                    var g; g = k.firstChild; var h = null; if (g) {</span></div>
<div class="line"><a name="l00205"></a><span class="lineno">  205</span>&#160;<span class="stringliteral">                                        do if (h) h.push(g); else if (b(g)) { var n = e(g, !0); n ? g = n : h = [g] } else c(g) &amp;&amp; (h = [g]); while (g =</span></div>
<div class="line"><a name="l00206"></a><span class="lineno">  206</span>&#160;<span class="stringliteral">                                        g.nextSibling)</span></div>
<div class="line"><a name="l00207"></a><span class="lineno">  207</span>&#160;<span class="stringliteral">                                    } if (g = h) for (h = k.nextSibling, n = 0; n &lt; g.length; n++) h ? d.insertBefore(g[n], h) : d.appendChild(g[n])</span></div>
<div class="line"><a name="l00208"></a><span class="lineno">  208</span>&#160;<span class="stringliteral">                                } while (k = k.nextSibling)</span></div>
<div class="line"><a name="l00209"></a><span class="lineno">  209</span>&#160;<span class="stringliteral">                            }</span></div>
<div class="line"><a name="l00210"></a><span class="lineno">  210</span>&#160;<span class="stringliteral">                        }</span></div>
<div class="line"><a name="l00211"></a><span class="lineno">  211</span>&#160;<span class="stringliteral">                    }</span></div>
<div class="line"><a name="l00212"></a><span class="lineno">  212</span>&#160;<span class="stringliteral">                }</span></div>
<div class="line"><a name="l00213"></a><span class="lineno">  213</span>&#160;<span class="stringliteral">            })(); a.b(&quot;</span>virtualElements<span class="stringliteral">&quot;, a.e); a.b(&quot;</span>virtualElements.allowedBindings<span class="stringliteral">&quot;, a.e.P); a.b(&quot;</span>virtualElements.emptyNode<span class="stringliteral">&quot;, a.e.Z); a.b(&quot;</span>virtualElements.insertAfter<span class="stringliteral">&quot;, a.e.eb); a.b(&quot;</span>virtualElements.prepend<span class="stringliteral">&quot;, a.e.kb); a.b(&quot;</span>virtualElements.setDomNodeChildren<span class="stringliteral">&quot;, a.e.S); (function () {</span></div>
<div class="line"><a name="l00214"></a><span class="lineno">  214</span>&#160;<span class="stringliteral">                a.H = function () { this.zb = {} }; a.a.extend(a.H.prototype, {</span></div>
<div class="line"><a name="l00215"></a><span class="lineno">  215</span>&#160;<span class="stringliteral">                    nodeHasBindings: function (b) {</span></div>
<div class="line"><a name="l00216"></a><span class="lineno">  216</span>&#160;<span class="stringliteral">                        switch (b.nodeType) {</span></div>
<div class="line"><a name="l00217"></a><span class="lineno">  217</span>&#160;<span class="stringliteral">                            case 1: return null !=</span></div>
<div class="line"><a name="l00218"></a><span class="lineno">  218</span>&#160;<span class="stringliteral">                            b.getAttribute(&quot;</span>data-bind<span class="stringliteral">&quot;); case 8: return a.e.Mb(b); default: return !1</span></div>
<div class="line"><a name="l00219"></a><span class="lineno">  219</span>&#160;<span class="stringliteral">                        }</span></div>
<div class="line"><a name="l00220"></a><span class="lineno">  220</span>&#160;<span class="stringliteral">                    }, getBindings: function (a, c) { var d = this.getBindingsString(a, c); return d ? this.parseBindingsString(d, c, a) : null }, getBindingAccessors: function (a, c) { var d = this.getBindingsString(a, c); return d ? this.parseBindingsString(d, c, a, { valueAccessors: !0 }) : null }, getBindingsString: function (b) { switch (b.nodeType) { case 1: return b.getAttribute(&quot;</span>data-bind<span class="stringliteral">&quot;); case 8: return a.e.bc(b); default: return null } }, parseBindingsString: function (b, c, d, e) {</span></div>
<div class="line"><a name="l00221"></a><span class="lineno">  221</span>&#160;<span class="stringliteral">                        try {</span></div>
<div class="line"><a name="l00222"></a><span class="lineno">  222</span>&#160;<span class="stringliteral">                            var g = this.zb,</span></div>
<div class="line"><a name="l00223"></a><span class="lineno">  223</span>&#160;<span class="stringliteral">                            h = b + (e &amp;&amp; e.valueAccessors || &quot;</span><span class="stringliteral">&quot;), k; if (!(k = g[h])) { var m, f = &quot;</span>with($context){with($data||{}){<span class="keywordflow">return</span>{<span class="stringliteral">&quot; + a.g.ka(b, e) + &quot;</span>}}}<span class="stringliteral">&quot;; m = new Function(&quot;</span>$context<span class="stringliteral">&quot;, &quot;</span>$element<span class="stringliteral">&quot;, f); k = g[h] = m } return k(c, d)</span></div>
<div class="line"><a name="l00224"></a><span class="lineno">  224</span>&#160;<span class="stringliteral">                        } catch (p) { throw p.message = &quot;</span>Unable to parse bindings.\nBindings value: <span class="stringliteral">&quot; + b + &quot;</span>\nMessage: <span class="stringliteral">&quot; + p.message, p; }</span></div>
<div class="line"><a name="l00225"></a><span class="lineno">  225</span>&#160;<span class="stringliteral">                    }</span></div>
<div class="line"><a name="l00226"></a><span class="lineno">  226</span>&#160;<span class="stringliteral">                }); a.H.instance = new a.H</span></div>
<div class="line"><a name="l00227"></a><span class="lineno">  227</span>&#160;<span class="stringliteral">            })(); a.b(&quot;</span>bindingProvider<span class="stringliteral">&quot;, a.H); (function () {</span></div>
<div class="line"><a name="l00228"></a><span class="lineno">  228</span>&#160;<span class="stringliteral">                function b(a) { return function () { return a } } function c(a) { return a() } function d(b) { return a.a.Da(a.i.p(b), function (a, c) { return function () { return b()[c] } }) } function e(a,</span></div>
<div class="line"><a name="l00229"></a><span class="lineno">  229</span>&#160;<span class="stringliteral">                b) { return d(this.getBindings.bind(this, a, b)) } function g(b, c, d) { var f, e = a.e.firstChild(c), k = a.H.instance, g = k.preprocessNode; if (g) { for (; f = e;) e = a.e.nextSibling(f), g.call(k, f); e = a.e.firstChild(c) } for (; f = e;) e = a.e.nextSibling(f), h(b, f, d) } function h(b, c, d) { var f = !0, e = 1 === c.nodeType; e &amp;&amp; a.e.ib(c); if (e &amp;&amp; d || a.H.instance.nodeHasBindings(c)) f = m(c, null, b, d).shouldBindDescendants; f &amp;&amp; !p[a.a.v(c)] &amp;&amp; g(b, c, !e) } function k(b) {</span></div>
<div class="line"><a name="l00230"></a><span class="lineno">  230</span>&#160;<span class="stringliteral">                    var c = [], d = {}, f = []; a.a.K(b, function D(e) {</span></div>
<div class="line"><a name="l00231"></a><span class="lineno">  231</span>&#160;<span class="stringliteral">                        if (!d[e]) {</span></div>
<div class="line"><a name="l00232"></a><span class="lineno">  232</span>&#160;<span class="stringliteral">                            var k = a.getBindingHandler(e); k &amp;&amp; (k.after &amp;&amp;</span></div>
<div class="line"><a name="l00233"></a><span class="lineno">  233</span>&#160;<span class="stringliteral">                            (f.push(e), a.a.n(k.after, function (c) { if (b[c]) { if (-1 !== a.a.l(f, c)) throw Error(&quot;</span>Cannot combine the following bindings, because they have a cyclic dependency: <span class="stringliteral">&quot; + f.join(&quot;</span>, <span class="stringliteral">&quot;)); D(c) } }), f.pop()), c.push({ key: e, bb: k })); d[e] = !0</span></div>
<div class="line"><a name="l00234"></a><span class="lineno">  234</span>&#160;<span class="stringliteral">                        }</span></div>
<div class="line"><a name="l00235"></a><span class="lineno">  235</span>&#160;<span class="stringliteral">                    }); return c</span></div>
<div class="line"><a name="l00236"></a><span class="lineno">  236</span>&#160;<span class="stringliteral">                } function m(b, d, f, g) {</span></div>
<div class="line"><a name="l00237"></a><span class="lineno">  237</span>&#160;<span class="stringliteral">                    var h = a.a.f.get(b, s); if (!d) { if (h) throw Error(&quot;</span>You cannot apply bindings multiple times to the same element.<span class="stringliteral">&quot;); a.a.f.set(b, s, !0) } !h &amp;&amp; g &amp;&amp; a.rb(b, f); var m; if (d &amp;&amp; &quot;</span>function<span class="stringliteral">&quot; !== typeof d) m = d; else {</span></div>
<div class="line"><a name="l00238"></a><span class="lineno">  238</span>&#160;<span class="stringliteral">                        var p = a.H.instance, l = p.getBindingAccessors || e; if (d || f.A) {</span></div>
<div class="line"><a name="l00239"></a><span class="lineno">  239</span>&#160;<span class="stringliteral">                            var A =</span></div>
<div class="line"><a name="l00240"></a><span class="lineno">  240</span>&#160;<span class="stringliteral">                            a.h(function () { (m = d ? d(f, b) : l.call(p, b, f)) &amp;&amp; f.A &amp;&amp; f.A(); return m }, null, { I: b }); m &amp;&amp; A.aa() || (A = null)</span></div>
<div class="line"><a name="l00241"></a><span class="lineno">  241</span>&#160;<span class="stringliteral">                        } else m = a.i.p(l, p, [b, f])</span></div>
<div class="line"><a name="l00242"></a><span class="lineno">  242</span>&#160;<span class="stringliteral">                    } var u; if (m) {</span></div>
<div class="line"><a name="l00243"></a><span class="lineno">  243</span>&#160;<span class="stringliteral">                        var w = A ? function (a) { return function () { return c(A()[a]) } } : function (a) { return m[a] }, y = function () { return a.a.Da(A ? A() : m, c) }; y.get = function (a) { return m[a] &amp;&amp; c(w(a)) }; y.has = function (a) { return a in m }; g = k(m); a.a.n(g, function (c) {</span></div>
<div class="line"><a name="l00244"></a><span class="lineno">  244</span>&#160;<span class="stringliteral">                            var d = c.bb.init, e = c.bb.update, k = c.key; if (8 === b.nodeType &amp;&amp; !a.e.P[k]) throw Error(&quot;</span>The binding <span class="stringliteral">&#39;&quot; + k + &quot;&#39;</span> cannot be used with <span class="keyword">virtual</span> elements<span class="stringliteral">&quot;); try {</span></div>
<div class="line"><a name="l00245"></a><span class="lineno">  245</span>&#160;<span class="stringliteral">                                &quot;</span><span class="keyword">function</span><span class="stringliteral">&quot; ==</span></div>
<div class="line"><a name="l00246"></a><span class="lineno">  246</span>&#160;<span class="stringliteral">                                typeof d &amp;&amp; a.i.p(function () { var a = d(b, w(k), y, f.$data, f); if (a &amp;&amp; a.controlsDescendantBindings) { if (u !== q) throw Error(&quot;</span>Multiple bindings (<span class="stringliteral">&quot; + u + &quot;</span> and <span class="stringliteral">&quot; + k + &quot;</span>) are trying to control descendant bindings of the same element. You cannot use these bindings together on the same element.&quot;); u = k } }), &quot;function&quot; == typeof e &amp;&amp; a.h(function () { e(b, w(k), y, f.$data, f) }, null, { I: b })</div>
<div class="line"><a name="l00247"></a><span class="lineno">  247</span>&#160;                            } <span class="keywordflow">catch</span> (g) { <span class="keywordflow">throw</span> g.message = <span class="stringliteral">&#39;Unable to process binding &quot;&#39;</span> + k + <span class="stringliteral">&quot;: &quot;</span> + m[k] + <span class="stringliteral">&#39;&quot;\nMessage: &#39;</span> + g.message, g; }</div>
<div class="line"><a name="l00248"></a><span class="lineno">  248</span>&#160;                        })</div>
<div class="line"><a name="l00249"></a><span class="lineno">  249</span>&#160;                    } <span class="keywordflow">return</span> { shouldBindDescendants: u === q }</div>
<div class="line"><a name="l00250"></a><span class="lineno">  250</span>&#160;                } <span class="keyword">function</span> f(b) {</div>
<div class="line"><a name="l00251"></a><span class="lineno">  251</span>&#160;                    <span class="keywordflow">return</span> b &amp;&amp;</div>
<div class="line"><a name="l00252"></a><span class="lineno">  252</span>&#160;                    b instanceof a.G ? b : <span class="keyword">new</span> a.G(b)</div>
<div class="line"><a name="l00253"></a><span class="lineno">  253</span>&#160;                } a.d = {}; var p = { script: !0 }; a.getBindingHandler = <span class="keyword">function</span> (b) { <span class="keywordflow">return</span> a.d[b] }; a.G = <span class="keyword">function</span> (b, c, d, f) {</div>
<div class="line"><a name="l00254"></a><span class="lineno">  254</span>&#160;                    var e = <span class="keyword">this</span>, k = <span class="stringliteral">&quot;function&quot;</span> == typeof b, g, h = a.h(<span class="keyword">function</span> () { var g = k ? b() : b; c ? (c.A &amp;&amp; c.A(), a.a.extend(e, c), h &amp;&amp; (e.A = h)) : (e.$parents = [], e.$root = g, e.ko = a); e.$rawData = b; e.$data = g; d &amp;&amp; (e[d] = g); f &amp;&amp; f(e, c, g); <span class="keywordflow">return</span> e.$data }, null, { ua: <span class="keyword">function</span> () { <span class="keywordflow">return</span> g &amp;&amp; !a.a.Ra(g) }, I: !0 }); h.aa() &amp;&amp; (e.A = h, h.equalityComparer = null, g = [], h.wb = <span class="keyword">function</span> (b) {</div>
<div class="line"><a name="l00255"></a><span class="lineno">  255</span>&#160;                        g.push(b); a.a.C.ea(b, <span class="keyword">function</span> (b) {</div>
<div class="line"><a name="l00256"></a><span class="lineno">  256</span>&#160;                            a.a.ia(g, b); g.length || (h.B(),</div>
<div class="line"><a name="l00257"></a><span class="lineno">  257</span>&#160;                            e.A = h = q)</div>
<div class="line"><a name="l00258"></a><span class="lineno">  258</span>&#160;                        })</div>
<div class="line"><a name="l00259"></a><span class="lineno">  259</span>&#160;                    })</div>
<div class="line"><a name="l00260"></a><span class="lineno">  260</span>&#160;                }; a.G.prototype.createChildContext = <span class="keyword">function</span> (b, c, d) { <span class="keywordflow">return</span> <span class="keyword">new</span> a.G(b, <span class="keyword">this</span>, c, <span class="keyword">function</span> (a, b) { a.$parentContext = b; a.$parent = b.$data; a.$parents = (b.$parents || []).slice(0); a.$parents.unshift(a.$parent); d &amp;&amp; d(a) }) }; a.G.prototype.extend = <span class="keyword">function</span> (b) { <span class="keywordflow">return</span> <span class="keyword">new</span> a.G(this.$rawData, <span class="keyword">this</span>, null, <span class="keyword">function</span> (c) { a.a.extend(c, <span class="stringliteral">&quot;function&quot;</span> == typeof b ? b() : b) }) }; var s = a.a.f.D(), l = a.a.f.D(); a.rb = <span class="keyword">function</span> (b, c) { <span class="keywordflow">if</span> (2 == arguments.length) a.a.f.set(b, l, c), c.A &amp;&amp; c.A.wb(b); <span class="keywordflow">else</span> <span class="keywordflow">return</span> a.a.f.get(b, l) }; a.pa = <span class="keyword">function</span> (b, c, d) {</div>
<div class="line"><a name="l00261"></a><span class="lineno">  261</span>&#160;                    1 === b.nodeType &amp;&amp;</div>
<div class="line"><a name="l00262"></a><span class="lineno">  262</span>&#160;                    a.e.ib(b); <span class="keywordflow">return</span> m(b, c, f(d), !0)</div>
<div class="line"><a name="l00263"></a><span class="lineno">  263</span>&#160;                }; a.xb = <span class="keyword">function</span> (c, e, k) { k = f(k); <span class="keywordflow">return</span> a.pa(c, <span class="stringliteral">&quot;function&quot;</span> === typeof e ? d(e.bind(null, k, c)) : a.a.Da(e, b), k) }; a.Ta = <span class="keyword">function</span> (a, b) { 1 !== b.nodeType &amp;&amp; 8 !== b.nodeType || g(f(a), b, !0) }; a.Sa = <span class="keyword">function</span> (a, b) { <span class="keywordflow">if</span> (b &amp;&amp; 1 !== b.nodeType &amp;&amp; 8 !== b.nodeType) <span class="keywordflow">throw</span> Error(<span class="stringliteral">&quot;ko.applyBindings: first parameter should be your view model; second parameter should be a DOM node&quot;</span>); b = b || y.document.body; h(f(a), b, !0) }; a.ta = <span class="keyword">function</span> (b) { <span class="keywordflow">switch</span> (b.nodeType) { <span class="keywordflow">case</span> 1: <span class="keywordflow">case</span> 8: var c = a.rb(b); <span class="keywordflow">if</span> (c) <span class="keywordflow">return</span> c; <span class="keywordflow">if</span> (b.parentNode) <span class="keywordflow">return</span> a.ta(b.parentNode) } <span class="keywordflow">return</span> q };</div>
<div class="line"><a name="l00264"></a><span class="lineno">  264</span>&#160;                a.Cb = <span class="keyword">function</span> (b) { <span class="keywordflow">return</span> (b = a.ta(b)) ? b.$data : q }; a.b(<span class="stringliteral">&quot;bindingHandlers&quot;</span>, a.d); a.b(<span class="stringliteral">&quot;applyBindings&quot;</span>, a.Sa); a.b(<span class="stringliteral">&quot;applyBindingsToDescendants&quot;</span>, a.Ta); a.b(<span class="stringliteral">&quot;applyBindingAccessorsToNode&quot;</span>, a.pa); a.b(<span class="stringliteral">&quot;applyBindingsToNode&quot;</span>, a.xb); a.b(<span class="stringliteral">&quot;contextFor&quot;</span>, a.ta); a.b(<span class="stringliteral">&quot;dataFor&quot;</span>, a.Cb)</div>
<div class="line"><a name="l00265"></a><span class="lineno">  265</span>&#160;            })(); var M = { <span class="stringliteral">&quot;class&quot;</span>: <span class="stringliteral">&quot;className&quot;</span>, <span class="stringliteral">&quot;for&quot;</span>: <span class="stringliteral">&quot;htmlFor&quot;</span> }; a.d.attr = {</div>
<div class="line"><a name="l00266"></a><span class="lineno">  266</span>&#160;                update: <span class="keyword">function</span> (b, c) {</div>
<div class="line"><a name="l00267"></a><span class="lineno">  267</span>&#160;                    var d = a.a.c(c()) || {}; a.a.K(d, <span class="keyword">function</span> (c, d) {</div>
<div class="line"><a name="l00268"></a><span class="lineno">  268</span>&#160;                        d = a.a.c(d); var h = !1 === d || null === d || d === q; h &amp;&amp; b.removeAttribute(c); 8 &gt;= a.a.ja &amp;&amp; c in M ? (c = M[c], h ? b.removeAttribute(c) : b[c] = d) : h || b.setAttribute(c,</div>
<div class="line"><a name="l00269"></a><span class="lineno">  269</span>&#160;                        d.toString()); <span class="stringliteral">&quot;name&quot;</span> === c &amp;&amp; a.a.pb(b, h ? <span class="stringliteral">&quot;&quot;</span> : d.toString())</div>
<div class="line"><a name="l00270"></a><span class="lineno">  270</span>&#160;                    })</div>
<div class="line"><a name="l00271"></a><span class="lineno">  271</span>&#160;                }</div>
<div class="line"><a name="l00272"></a><span class="lineno">  272</span>&#160;            }; (<span class="keyword">function</span> () {</div>
<div class="line"><a name="l00273"></a><span class="lineno">  273</span>&#160;                a.d.checked = {</div>
<div class="line"><a name="l00274"></a><span class="lineno">  274</span>&#160;                    after: [<span class="stringliteral">&quot;value&quot;</span>, <span class="stringliteral">&quot;attr&quot;</span>], init: <span class="keyword">function</span> (b, c, d) {</div>
<div class="line"><a name="l00275"></a><span class="lineno">  275</span>&#160;                        <span class="keyword">function</span> e() { <span class="keywordflow">return</span> d.has(<span class="stringliteral">&quot;checkedValue&quot;</span>) ? a.a.c(d.get(<span class="stringliteral">&quot;checkedValue&quot;</span>)) : b.value } <span class="keyword">function</span> g() { var k = b.checked, g = s ? e() : k; <span class="keywordflow">if</span> (l &amp;&amp; (!m || k)) { var h = a.i.p(c); f ? p !== g ? (k &amp;&amp; (a.a.V(h, g, !0), a.a.V(h, p, !1)), p = g) : a.a.V(h, g, k) : a.g.oa(h, d, <span class="stringliteral">&quot;checked&quot;</span>, g, !0) } } function h() { var d = a.a.c(c()); b.checked = f ? 0 &lt;= a.a.l(d, e()) : k ? d : e() === d } var k = <span class="stringliteral">&quot;checkbox&quot;</span> == b.type, m = <span class="stringliteral">&quot;radio&quot;</span> == b.type; <span class="keywordflow">if</span> (k || m) {</div>
<div class="line"><a name="l00276"></a><span class="lineno">  276</span>&#160;                            var f = k &amp;&amp; a.a.c(c()) instanceof</div>
<div class="line"><a name="l00277"></a><span class="lineno">  277</span>&#160;                            Array, p = f ? e() : q, s = m || f, l = !1; m &amp;&amp; !b.name &amp;&amp; a.d.uniqueName.init(b, <span class="keyword">function</span> () { <span class="keywordflow">return</span> !0 }); a.h(g, null, { I: b }); a.a.r(b, <span class="stringliteral">&quot;click&quot;</span>, g); a.h(h, null, { I: b }); l = !0</div>
<div class="line"><a name="l00278"></a><span class="lineno">  278</span>&#160;                        }</div>
<div class="line"><a name="l00279"></a><span class="lineno">  279</span>&#160;                    }</div>
<div class="line"><a name="l00280"></a><span class="lineno">  280</span>&#160;                }; a.g.U.checked = !0; a.d.checkedValue = { update: <span class="keyword">function</span> (b, c) { b.value = a.a.c(c()) } }</div>
<div class="line"><a name="l00281"></a><span class="lineno">  281</span>&#160;            })(); a.d.css = { update: <span class="keyword">function</span> (b, c) { var d = a.a.c(c()); <span class="stringliteral">&quot;object&quot;</span> == typeof d ? a.a.K(d, <span class="keyword">function</span> (c, d) { d = a.a.c(d); a.a.ma(b, c, d) }) : (d = String(d || <span class="stringliteral">&quot;&quot;</span>), a.a.ma(b, b.__ko__cssValue, !1), b.__ko__cssValue = d, a.a.ma(b, d, !0)) } }; a.d.enable = {</div>
<div class="line"><a name="l00282"></a><span class="lineno">  282</span>&#160;                update: <span class="keyword">function</span> (b, c) {</div>
<div class="line"><a name="l00283"></a><span class="lineno">  283</span>&#160;                    var d = a.a.c(c()); d &amp;&amp; b.disabled ? b.removeAttribute(<span class="stringliteral">&quot;disabled&quot;</span>) :</div>
<div class="line"><a name="l00284"></a><span class="lineno">  284</span>&#160;                    d || b.disabled || (b.disabled = !0)</div>
<div class="line"><a name="l00285"></a><span class="lineno">  285</span>&#160;                }</div>
<div class="line"><a name="l00286"></a><span class="lineno">  286</span>&#160;            }; a.d.disable = { update: <span class="keyword">function</span> (b, c) { a.d.enable.update(b, <span class="keyword">function</span> () { <span class="keywordflow">return</span> !a.a.c(c()) }) } }; a.d.event = { init: <span class="keyword">function</span> (b, c, d, e, g) { var h = c() || {}; a.a.K(h, <span class="keyword">function</span> (k) { <span class="stringliteral">&quot;string&quot;</span> == typeof k &amp;&amp; a.a.r(b, k, <span class="keyword">function</span> (b) { var f, h = c()[k]; <span class="keywordflow">if</span> (h) { <span class="keywordflow">try</span> { var s = a.a.Q(arguments); e = g.$data; s.unshift(e); f = h.apply(e, s) } <span class="keywordflow">finally</span> { !0 !== f &amp;&amp; (b.preventDefault ? b.preventDefault() : b.returnValue = !1) } !1 === d.get(k + <span class="stringliteral">&quot;Bubble&quot;</span>) &amp;&amp; (b.cancelBubble = !0, b.stopPropagation &amp;&amp; b.stopPropagation()) } }) }) } }; a.d.foreach = {</div>
<div class="line"><a name="l00287"></a><span class="lineno">  287</span>&#160;                hb: <span class="keyword">function</span> (b) {</div>
<div class="line"><a name="l00288"></a><span class="lineno">  288</span>&#160;                    <span class="keywordflow">return</span> <span class="keyword">function</span> () {</div>
<div class="line"><a name="l00289"></a><span class="lineno">  289</span>&#160;                        var c =</div>
<div class="line"><a name="l00290"></a><span class="lineno">  290</span>&#160;                        b(), d = a.a.Ha(c); <span class="keywordflow">if</span> (!d || <span class="stringliteral">&quot;number&quot;</span> == typeof d.length) <span class="keywordflow">return</span> { <span class="keywordflow">foreach</span>: c, templateEngine: a.J.Aa }; a.a.c(c); <span class="keywordflow">return</span> { <span class="keywordflow">foreach</span>: d.data, as: d.as, includeDestroyed: d.includeDestroyed, afterAdd: d.afterAdd, beforeRemove: d.beforeRemove, afterRender: d.afterRender, beforeMove: d.beforeMove, afterMove: d.afterMove, templateEngine: a.J.Aa }</div>
<div class="line"><a name="l00291"></a><span class="lineno">  291</span>&#160;                    }</div>
<div class="line"><a name="l00292"></a><span class="lineno">  292</span>&#160;                }, init: <span class="keyword">function</span> (b, c) { <span class="keywordflow">return</span> a.d.template.init(b, a.d.foreach.hb(c)) }, update: <span class="keyword">function</span> (b, c, d, e, g) { <span class="keywordflow">return</span> a.d.template.update(b, a.d.foreach.hb(c), d, e, g) }</div>
<div class="line"><a name="l00293"></a><span class="lineno">  293</span>&#160;            }; a.g.Y.foreach = !1; a.e.P.foreach = !0; a.d.hasfocus =</div>
<div class="line"><a name="l00294"></a><span class="lineno">  294</span>&#160;            {</div>
<div class="line"><a name="l00295"></a><span class="lineno">  295</span>&#160;                init: <span class="keyword">function</span> (b, c, d) { <span class="keyword">function</span> e(e) { b.__ko_hasfocusUpdating = !0; var g = b.ownerDocument; <span class="keywordflow">if</span> (<span class="stringliteral">&quot;activeElement&quot;</span> in g) { var f; <span class="keywordflow">try</span> { f = g.activeElement } <span class="keywordflow">catch</span> (h) { f = g.body } e = f === b } g = c(); a.g.oa(g, d, <span class="stringliteral">&quot;hasfocus&quot;</span>, e, !0); b.__ko_hasfocusLastValue = e; b.__ko_hasfocusUpdating = !1 } var g = e.bind(null, !0), h = e.bind(null, !1); a.a.r(b, <span class="stringliteral">&quot;focus&quot;</span>, g); a.a.r(b, <span class="stringliteral">&quot;focusin&quot;</span>, g); a.a.r(b, <span class="stringliteral">&quot;blur&quot;</span>, h); a.a.r(b, <span class="stringliteral">&quot;focusout&quot;</span>, h) }, update: <span class="keyword">function</span> (b, c) {</div>
<div class="line"><a name="l00296"></a><span class="lineno">  296</span>&#160;                    var d = !!a.a.c(c()); b.__ko_hasfocusUpdating || b.__ko_hasfocusLastValue === d || (d ? b.focus() : b.blur(), a.i.p(a.a.da,</div>
<div class="line"><a name="l00297"></a><span class="lineno">  297</span>&#160;                    null, [b, d ? <span class="stringliteral">&quot;focusin&quot;</span> : <span class="stringliteral">&quot;focusout&quot;</span>]))</div>
<div class="line"><a name="l00298"></a><span class="lineno">  298</span>&#160;                }</div>
<div class="line"><a name="l00299"></a><span class="lineno">  299</span>&#160;            }; a.g.U.hasfocus = !0; a.d.hasFocus = a.d.hasfocus; a.g.U.hasFocus = !0; a.d.html = { init: <span class="keyword">function</span> () { <span class="keywordflow">return</span> { controlsDescendantBindings: !0 } }, update: <span class="keyword">function</span> (b, c) { a.a.Ka(b, c()) } }; var L = a.a.f.D(); H(<span class="stringliteral">&quot;if&quot;</span>); H(<span class="stringliteral">&quot;ifnot&quot;</span>, !1, !0); H(<span class="stringliteral">&quot;with&quot;</span>, !0, !1, <span class="keyword">function</span> (a, c) { <span class="keywordflow">return</span> a.createChildContext(c) }); a.d.options = {</div>
<div class="line"><a name="l00300"></a><span class="lineno">  300</span>&#160;                init: <span class="keyword">function</span> (b) { <span class="keywordflow">if</span> (<span class="stringliteral">&quot;select&quot;</span> !== a.a.v(b)) <span class="keywordflow">throw</span> Error(<span class="stringliteral">&quot;options binding applies only to SELECT elements&quot;</span>); <span class="keywordflow">for</span> (; 0 &lt; b.length;) b.remove(0); <span class="keywordflow">return</span> { controlsDescendantBindings: !0 } }, update: <span class="keyword">function</span> (b,</div>
<div class="line"><a name="l00301"></a><span class="lineno">  301</span>&#160;                c, d) {</div>
<div class="line"><a name="l00302"></a><span class="lineno">  302</span>&#160;                    <span class="keyword">function</span> e() { <span class="keywordflow">return</span> a.a.ga(b.options, function (a) { <span class="keywordflow">return</span> a.selected }) } <span class="keyword">function</span> g(a, b, c) { var d = typeof b; <span class="keywordflow">return</span> <span class="stringliteral">&quot;function&quot;</span> == d ? b(a) : <span class="stringliteral">&quot;string&quot;</span> == d ? a[b] : c } function h(c, d) { <span class="keywordflow">if</span> (p.length) { var f = 0 &lt;= a.a.l(p, a.k.o(d[0])); a.a.qb(d[0], f); l &amp;&amp; !f &amp;&amp; a.i.p(a.a.da, null, [b, <span class="stringliteral">&quot;change&quot;</span>]) } } var k = 0 != b.length &amp;&amp; b.multiple ? b.scrollTop : null; c = a.a.c(c()); var m = d.get(<span class="stringliteral">&quot;optionsIncludeDestroyed&quot;</span>), f = {}, p; p = b.multiple ? a.a.ha(e(), a.k.o) : 0 &lt;= b.selectedIndex ? [a.k.o(b.options[b.selectedIndex])] : []; <span class="keywordflow">if</span> (c) {</div>
<div class="line"><a name="l00303"></a><span class="lineno">  303</span>&#160;                        <span class="stringliteral">&quot;undefined&quot;</span> == typeof c.length &amp;&amp; (c = [c]);</div>
<div class="line"><a name="l00304"></a><span class="lineno">  304</span>&#160;                        var s = a.a.ga(c, <span class="keyword">function</span> (b) { <span class="keywordflow">return</span> m || b === q || null === b || !a.a.c(b._destroy) }); d.has(<span class="stringliteral">&quot;optionsCaption&quot;</span>) &amp;&amp; (c = a.a.c(d.get(<span class="stringliteral">&quot;optionsCaption&quot;</span>)), null !== c &amp;&amp; c !== q &amp;&amp; s.unshift(f))</div>
<div class="line"><a name="l00305"></a><span class="lineno">  305</span>&#160;                    } <span class="keywordflow">else</span> c = []; var l = !1; c = h; d.has(<span class="stringliteral">&quot;optionsAfterRender&quot;</span>) &amp;&amp; (c = <span class="keyword">function</span> (b, c) { h(0, c); a.i.p(d.get(<span class="stringliteral">&quot;optionsAfterRender&quot;</span>), null, [c[0], b !== f ? b : q]) }); a.a.Ja(b, s, <span class="keyword">function</span> (b, c, e) {</div>
<div class="line"><a name="l00306"></a><span class="lineno">  306</span>&#160;                        e.length &amp;&amp; (p = e[0].selected ? [a.k.o(e[0])] : [], l = !0); c = w.createElement(<span class="stringliteral">&quot;option&quot;</span>); b === f ? (a.a.Ma(c, d.get(<span class="stringliteral">&quot;optionsCaption&quot;</span>)), a.k.na(c, q)) : (e = g(b, d.get(<span class="stringliteral">&quot;optionsValue&quot;</span>), b), a.k.na(c, a.a.c(e)),</div>
<div class="line"><a name="l00307"></a><span class="lineno">  307</span>&#160;                        b = g(b, d.get(<span class="stringliteral">&quot;optionsText&quot;</span>), e), a.a.Ma(c, b)); <span class="keywordflow">return</span> [c]</div>
<div class="line"><a name="l00308"></a><span class="lineno">  308</span>&#160;                    }, null, c); (b.multiple ? p.length &amp;&amp; e().length &lt; p.length : p.length &amp;&amp; 0 &lt;= b.selectedIndex ? a.k.o(b.options[b.selectedIndex]) !== p[0] : p.length || 0 &lt;= b.selectedIndex) &amp;&amp; a.i.p(a.a.da, null, [b, <span class="stringliteral">&quot;change&quot;</span>]); a.a.Hb(b); k &amp;&amp; 20 &lt; Math.abs(k - b.scrollTop) &amp;&amp; (b.scrollTop = k)</div>
<div class="line"><a name="l00309"></a><span class="lineno">  309</span>&#160;                }</div>
<div class="line"><a name="l00310"></a><span class="lineno">  310</span>&#160;            }; a.d.options.Ea = a.a.f.D(); a.d.selectedOptions = {</div>
<div class="line"><a name="l00311"></a><span class="lineno">  311</span>&#160;                after: [<span class="stringliteral">&quot;options&quot;</span>, <span class="stringliteral">&quot;foreach&quot;</span>], init: <span class="keyword">function</span> (b, c, d) {</div>
<div class="line"><a name="l00312"></a><span class="lineno">  312</span>&#160;                    a.a.r(b, <span class="stringliteral">&quot;change&quot;</span>, <span class="keyword">function</span> () {</div>
<div class="line"><a name="l00313"></a><span class="lineno">  313</span>&#160;                        var e = c(), g = []; a.a.n(b.getElementsByTagName(<span class="stringliteral">&quot;option&quot;</span>), <span class="keyword">function</span> (b) { b.selected &amp;&amp; g.push(a.k.o(b)) });</div>
<div class="line"><a name="l00314"></a><span class="lineno">  314</span>&#160;                        a.g.oa(e, d, <span class="stringliteral">&quot;selectedOptions&quot;</span>, g)</div>
<div class="line"><a name="l00315"></a><span class="lineno">  315</span>&#160;                    })</div>
<div class="line"><a name="l00316"></a><span class="lineno">  316</span>&#160;                }, update: <span class="keyword">function</span> (b, c) { <span class="keywordflow">if</span> (<span class="stringliteral">&quot;select&quot;</span> != a.a.v(b)) <span class="keywordflow">throw</span> Error(<span class="stringliteral">&quot;values binding applies only to SELECT elements&quot;</span>); var d = a.a.c(c()); d &amp;&amp; <span class="stringliteral">&quot;number&quot;</span> == typeof d.length &amp;&amp; a.a.n(b.getElementsByTagName(<span class="stringliteral">&quot;option&quot;</span>), <span class="keyword">function</span> (b) { var c = 0 &lt;= a.a.l(d, a.k.o(b)); a.a.qb(b, c) }) }</div>
<div class="line"><a name="l00317"></a><span class="lineno">  317</span>&#160;            }; a.g.U.selectedOptions = !0; a.d.style = { update: <span class="keyword">function</span> (b, c) { var d = a.a.c(c() || {}); a.a.K(d, <span class="keyword">function</span> (c, d) { d = a.a.c(d); b.style[c] = d || <span class="stringliteral">&quot;&quot;</span> }) } }; a.d.submit = {</div>
<div class="line"><a name="l00318"></a><span class="lineno">  318</span>&#160;                init: <span class="keyword">function</span> (b, c, d, e, g) {</div>
<div class="line"><a name="l00319"></a><span class="lineno">  319</span>&#160;                    <span class="keywordflow">if</span> (<span class="stringliteral">&quot;function&quot;</span> != typeof c()) <span class="keywordflow">throw</span> Error(<span class="stringliteral">&quot;The value for a submit binding must be a function&quot;</span>);</div>
<div class="line"><a name="l00320"></a><span class="lineno">  320</span>&#160;                    a.a.r(b, <span class="stringliteral">&quot;submit&quot;</span>, <span class="keyword">function</span> (a) { var d, e = c(); <span class="keywordflow">try</span> { d = e.call(g.$data, b) } <span class="keywordflow">finally</span> { !0 !== d &amp;&amp; (a.preventDefault ? a.preventDefault() : a.returnValue = !1) } })</div>
<div class="line"><a name="l00321"></a><span class="lineno">  321</span>&#160;                }</div>
<div class="line"><a name="l00322"></a><span class="lineno">  322</span>&#160;            }; a.d.text = { init: <span class="keyword">function</span> () { <span class="keywordflow">return</span> { controlsDescendantBindings: !0 } }, update: <span class="keyword">function</span> (b, c) { a.a.Ma(b, c()) } }; a.e.P.text = !0; a.d.uniqueName = { init: <span class="keyword">function</span> (b, c) { <span class="keywordflow">if</span> (c()) { var d = <span class="stringliteral">&quot;ko_unique_&quot;</span> + ++a.d.uniqueName.Bb; a.a.pb(b, d) } } }; a.d.uniqueName.Bb = 0; a.d.value = {</div>
<div class="line"><a name="l00323"></a><span class="lineno">  323</span>&#160;                after: [<span class="stringliteral">&quot;options&quot;</span>, <span class="stringliteral">&quot;foreach&quot;</span>], init: <span class="keyword">function</span> (b, c, d) {</div>
<div class="line"><a name="l00324"></a><span class="lineno">  324</span>&#160;                    <span class="keyword">function</span> e() { k = !1; var e = c(), f = a.k.o(b); a.g.oa(e, d, <span class="stringliteral">&quot;value&quot;</span>, f) } var g =</div>
<div class="line"><a name="l00325"></a><span class="lineno">  325</span>&#160;                    [<span class="stringliteral">&quot;change&quot;</span>], h = d.get(<span class="stringliteral">&quot;valueUpdate&quot;</span>), k = !1; h &amp;&amp; (<span class="stringliteral">&quot;string&quot;</span> == typeof h &amp;&amp; (h = [h]), a.a.X(g, h), g = a.a.Va(g)); !a.a.ja || <span class="stringliteral">&quot;input&quot;</span> != b.tagName.toLowerCase() || <span class="stringliteral">&quot;text&quot;</span> != b.type || <span class="stringliteral">&quot;off&quot;</span> == b.autocomplete || b.form &amp;&amp; <span class="stringliteral">&quot;off&quot;</span> == b.form.autocomplete || -1 != a.a.l(g, <span class="stringliteral">&quot;propertychange&quot;</span>) || (a.a.r(b, <span class="stringliteral">&quot;propertychange&quot;</span>, <span class="keyword">function</span> () { k = !0 }), a.a.r(b, <span class="stringliteral">&quot;blur&quot;</span>, function () { k &amp;&amp; e() })); a.a.n(g, <span class="keyword">function</span> (c) { var d = e; a.a.ac(c, <span class="stringliteral">&quot;after&quot;</span>) &amp;&amp; (d = <span class="keyword">function</span> () { setTimeout(e, 0) }, c = c.substring(5)); a.a.r(b, c, d) })</div>
<div class="line"><a name="l00326"></a><span class="lineno">  326</span>&#160;                }, update: <span class="keyword">function</span> (b, c) {</div>
<div class="line"><a name="l00327"></a><span class="lineno">  327</span>&#160;                    var d = <span class="stringliteral">&quot;select&quot;</span> === a.a.v(b), e = a.a.c(c()), g = a.k.o(b);</div>
<div class="line"><a name="l00328"></a><span class="lineno">  328</span>&#160;                    e !== g &amp;&amp; (g = <span class="keyword">function</span> () { a.k.na(b, e) }, g(), d &amp;&amp; (e !== a.k.o(b) ? a.i.p(a.a.da, null, [b, <span class="stringliteral">&quot;change&quot;</span>]) : setTimeout(g, 0)))</div>
<div class="line"><a name="l00329"></a><span class="lineno">  329</span>&#160;                }</div>
<div class="line"><a name="l00330"></a><span class="lineno">  330</span>&#160;            }; a.g.U.value = !0; a.d.visible = { update: <span class="keyword">function</span> (b, c) { var d = a.a.c(c()), e = <span class="stringliteral">&quot;none&quot;</span> != b.style.display; d &amp;&amp; !e ? b.style.display = <span class="stringliteral">&quot;&quot;</span> : !d &amp;&amp; e &amp;&amp; (b.style.display = <span class="stringliteral">&quot;none&quot;</span>) } }; (<span class="keyword">function</span> (b) { a.d[b] = { init: <span class="keyword">function</span> (c, d, e, g, h) { <span class="keywordflow">return</span> a.d.event.init.call(<span class="keyword">this</span>, c, <span class="keyword">function</span> () { var a = {}; a[b] = d(); <span class="keywordflow">return</span> a }, e, g, h) } } })(<span class="stringliteral">&quot;click&quot;</span>); a.w = <span class="keyword">function</span> () { }; a.w.prototype.renderTemplateSource = <span class="keyword">function</span> () {</div>
<div class="line"><a name="l00331"></a><span class="lineno">  331</span>&#160;                <span class="keywordflow">throw</span> Error(<span class="stringliteral">&quot;Override renderTemplateSource&quot;</span>);</div>
<div class="line"><a name="l00332"></a><span class="lineno">  332</span>&#160;            }; a.w.prototype.createJavaScriptEvaluatorBlock = <span class="keyword">function</span> () { <span class="keywordflow">throw</span> Error(<span class="stringliteral">&quot;Override createJavaScriptEvaluatorBlock&quot;</span>); }; a.w.prototype.makeTemplateSource = <span class="keyword">function</span> (b, c) { <span class="keywordflow">if</span> (<span class="stringliteral">&quot;string&quot;</span> == typeof b) { c = c || w; var d = c.getElementById(b); <span class="keywordflow">if</span> (!d) <span class="keywordflow">throw</span> Error(<span class="stringliteral">&quot;Cannot find template with ID &quot;</span> + b); <span class="keywordflow">return</span> <span class="keyword">new</span> a.m.j(d) } <span class="keywordflow">if</span> (1 == b.nodeType || 8 == b.nodeType) <span class="keywordflow">return</span> <span class="keyword">new</span> a.m.W(b); <span class="keywordflow">throw</span> Error(<span class="stringliteral">&quot;Unknown template type: &quot;</span> + b); }; a.w.prototype.renderTemplate = <span class="keyword">function</span> (a, c, d, e) {</div>
<div class="line"><a name="l00333"></a><span class="lineno">  333</span>&#160;                a = this.makeTemplateSource(a, e); <span class="keywordflow">return</span> this.renderTemplateSource(a, c,</div>
<div class="line"><a name="l00334"></a><span class="lineno">  334</span>&#160;                d)</div>
<div class="line"><a name="l00335"></a><span class="lineno">  335</span>&#160;            }; a.w.prototype.isTemplateRewritten = <span class="keyword">function</span> (a, c) { <span class="keywordflow">return</span> !1 === this.allowTemplateRewriting ? !0 : this.makeTemplateSource(a, c).data(<span class="stringliteral">&quot;isRewritten&quot;</span>) }; a.w.prototype.rewriteTemplate = <span class="keyword">function</span> (a, c, d) { a = this.makeTemplateSource(a, d); c = c(a.text()); a.text(c); a.data(<span class="stringliteral">&quot;isRewritten&quot;</span>, !0) }; a.b(<span class="stringliteral">&quot;templateEngine&quot;</span>, a.w); a.Oa = <span class="keyword">function</span> () {</div>
<div class="line"><a name="l00336"></a><span class="lineno">  336</span>&#160;                <span class="keyword">function</span> b(b, c, d, k) {</div>
<div class="line"><a name="l00337"></a><span class="lineno">  337</span>&#160;                    b = a.g.Ga(b); <span class="keywordflow">for</span> (var m = a.g.Y, f = 0; f &lt; b.length; f++) {</div>
<div class="line"><a name="l00338"></a><span class="lineno">  338</span>&#160;                        var p = b[f].key; <span class="keywordflow">if</span> (m.hasOwnProperty(p)) {</div>
<div class="line"><a name="l00339"></a><span class="lineno">  339</span>&#160;                            var s = m[p]; <span class="keywordflow">if</span> (<span class="stringliteral">&quot;function&quot;</span> === typeof s) { <span class="keywordflow">if</span> (p = s(b[f].value)) <span class="keywordflow">throw</span> Error(p); } <span class="keywordflow">else</span> <span class="keywordflow">if</span> (!s) <span class="keywordflow">throw</span> Error(<span class="stringliteral">&quot;This template engine does not support the &#39;&quot;</span> +</div>
<div class="line"><a name="l00340"></a><span class="lineno">  340</span>&#160;                            p + <span class="stringliteral">&quot;&#39; binding within its templates&quot;</span>);</div>
<div class="line"><a name="l00341"></a><span class="lineno">  341</span>&#160;                        }</div>
<div class="line"><a name="l00342"></a><span class="lineno">  342</span>&#160;                    } d = <span class="stringliteral">&quot;ko.__tr_ambtns(function($context,$element){return(function(){return{ &quot;</span> + a.g.ka(b, { valueAccessors: !0 }) + <span class="stringliteral">&quot; } })()},&#39;&quot;</span> + d.toLowerCase() + <span class="stringliteral">&quot;&#39;)&quot;</span>; <span class="keywordflow">return</span> k.createJavaScriptEvaluatorBlock(d) + c</div>
<div class="line"><a name="l00343"></a><span class="lineno">  343</span>&#160;                } var c = /(&lt;([a-z]+\d*)(?:\s+(?!data-bind\s*=\s*)[a-z0-9\-]+(?:=(?:\<span class="stringliteral">&quot;[^\&quot;]*\&quot;|\&#39;[^\&#39;]*\&#39;))?)*\s+)data-bind\s*=\s*([&quot;</span><span class="stringliteral">&#39;])([\s\S]*?)\3/gi, d = /\x3c!--\s*ko\b\s*([\s\S]*?)\s*--\x3e/g; return {</span></div>
<div class="line"><a name="l00344"></a><span class="lineno">  344</span>&#160;<span class="stringliteral">                    Ib: function (b, c, d) {</span></div>
<div class="line"><a name="l00345"></a><span class="lineno">  345</span>&#160;<span class="stringliteral">                        c.isTemplateRewritten(b, d) || c.rewriteTemplate(b, function (b) { return a.Oa.Ub(b, c) },</span></div>
<div class="line"><a name="l00346"></a><span class="lineno">  346</span>&#160;<span class="stringliteral">                        d)</span></div>
<div class="line"><a name="l00347"></a><span class="lineno">  347</span>&#160;<span class="stringliteral">                    }, Ub: function (a, g) { return a.replace(c, function (a, c, d, f, e) { return b(e, c, d, g) }).replace(d, function (a, c) { return b(c, &quot;\x3c!-- ko --\x3e&quot;, &quot;#comment&quot;, g) }) }, yb: function (b, c) { return a.u.Ca(function (d, k) { var m = d.nextSibling; m &amp;&amp; m.nodeName.toLowerCase() === c &amp;&amp; a.pa(m, b, k) }) }</span></div>
<div class="line"><a name="l00348"></a><span class="lineno">  348</span>&#160;<span class="stringliteral">                }</span></div>
<div class="line"><a name="l00349"></a><span class="lineno">  349</span>&#160;<span class="stringliteral">            }(); a.b(&quot;__tr_ambtns&quot;, a.Oa.yb); (function () {</span></div>
<div class="line"><a name="l00350"></a><span class="lineno">  350</span>&#160;<span class="stringliteral">                a.m = {}; a.m.j = function (a) { this.j = a }; a.m.j.prototype.text = function () {</span></div>
<div class="line"><a name="l00351"></a><span class="lineno">  351</span>&#160;<span class="stringliteral">                    var b = a.a.v(this.j), b = &quot;script&quot; === b ? &quot;text&quot; : &quot;textarea&quot; === b ? &quot;value&quot; : &quot;innerHTML&quot;; if (0 == arguments.length) return this.j[b]; var c = arguments[0];</span></div>
<div class="line"><a name="l00352"></a><span class="lineno">  352</span>&#160;<span class="stringliteral">                    &quot;innerHTML&quot; === b ? a.a.Ka(this.j, c) : this.j[b] = c</span></div>
<div class="line"><a name="l00353"></a><span class="lineno">  353</span>&#160;<span class="stringliteral">                }; var b = a.a.f.D() + &quot;_&quot;; a.m.j.prototype.data = function (c) { if (1 === arguments.length) return a.a.f.get(this.j, b + c); a.a.f.set(this.j, b + c, arguments[1]) }; var c = a.a.f.D(); a.m.W = function (a) { this.j = a }; a.m.W.prototype = new a.m.j; a.m.W.prototype.text = function () { if (0 == arguments.length) { var b = a.a.f.get(this.j, c) || {}; b.Pa === q &amp;&amp; b.sa &amp;&amp; (b.Pa = b.sa.innerHTML); return b.Pa } a.a.f.set(this.j, c, { Pa: arguments[0] }) }; a.m.j.prototype.nodes = function () {</span></div>
<div class="line"><a name="l00354"></a><span class="lineno">  354</span>&#160;<span class="stringliteral">                    if (0 == arguments.length) return (a.a.f.get(this.j,</span></div>
<div class="line"><a name="l00355"></a><span class="lineno">  355</span>&#160;<span class="stringliteral">                    c) || {}).sa; a.a.f.set(this.j, c, { sa: arguments[0] })</span></div>
<div class="line"><a name="l00356"></a><span class="lineno">  356</span>&#160;<span class="stringliteral">                }; a.b(&quot;templateSources&quot;, a.m); a.b(&quot;templateSources.domElement&quot;, a.m.j); a.b(&quot;templateSources.anonymousTemplate&quot;, a.m.W)</span></div>
<div class="line"><a name="l00357"></a><span class="lineno">  357</span>&#160;<span class="stringliteral">            })(); (function () {</span></div>
<div class="line"><a name="l00358"></a><span class="lineno">  358</span>&#160;<span class="stringliteral">                function b(b, c, d) { var e; for (c = a.e.nextSibling(c) ; b &amp;&amp; (e = b) !== c;) b = a.e.nextSibling(e), d(e, b) } function c(c, d) {</span></div>
<div class="line"><a name="l00359"></a><span class="lineno">  359</span>&#160;<span class="stringliteral">                    if (c.length) {</span></div>
<div class="line"><a name="l00360"></a><span class="lineno">  360</span>&#160;<span class="stringliteral">                        var f = c[0], e = c[c.length - 1], g = f.parentNode, h = a.H.instance, n = h.preprocessNode; if (n) {</span></div>
<div class="line"><a name="l00361"></a><span class="lineno">  361</span>&#160;<span class="stringliteral">                            b(f, e, function (a, b) { var c = a.previousSibling, d = n.call(h, a); d &amp;&amp; (a === f &amp;&amp; (f = d[0] || b), a === e &amp;&amp; (e = d[d.length - 1] || c)) }); c.length =</span></div>
<div class="line"><a name="l00362"></a><span class="lineno">  362</span>&#160;<span class="stringliteral">                            0; if (!f) return; f === e ? c.push(f) : (c.push(f, e), a.a.$(c, g))</span></div>
<div class="line"><a name="l00363"></a><span class="lineno">  363</span>&#160;<span class="stringliteral">                        } b(f, e, function (b) { 1 !== b.nodeType &amp;&amp; 8 !== b.nodeType || a.Sa(d, b) }); b(f, e, function (b) { 1 !== b.nodeType &amp;&amp; 8 !== b.nodeType || a.u.vb(b, [d]) }); a.a.$(c, g)</span></div>
<div class="line"><a name="l00364"></a><span class="lineno">  364</span>&#160;<span class="stringliteral">                    }</span></div>
<div class="line"><a name="l00365"></a><span class="lineno">  365</span>&#160;<span class="stringliteral">                } function d(a) { return a.nodeType ? a : 0 &lt; a.length ? a[0] : null } function e(b, e, f, h, s) {</span></div>
<div class="line"><a name="l00366"></a><span class="lineno">  366</span>&#160;<span class="stringliteral">                    s = s || {}; var l = b &amp;&amp; d(b), l = l &amp;&amp; l.ownerDocument, n = s.templateEngine || g; a.Oa.Ib(f, n, l); f = n.renderTemplate(f, h, s, l); if (&quot;number&quot; != typeof f.length || 0 &lt; f.length &amp;&amp; &quot;number&quot; != typeof f[0].nodeType) throw Error(&quot;Template engine must return an array of DOM nodes&quot;);</span></div>
<div class="line"><a name="l00367"></a><span class="lineno">  367</span>&#160;<span class="stringliteral">                    l = !1; switch (e) { case &quot;replaceChildren&quot;: a.e.S(b, f); l = !0; break; case &quot;replaceNode&quot;: a.a.nb(b, f); l = !0; break; case &quot;ignoreTargetNode&quot;: break; default: throw Error(&quot;Unknown renderMode: &quot; + e); } l &amp;&amp; (c(f, h), s.afterRender &amp;&amp; a.i.p(s.afterRender, null, [f, h.$data])); return f</span></div>
<div class="line"><a name="l00368"></a><span class="lineno">  368</span>&#160;<span class="stringliteral">                } var g; a.La = function (b) { if (b != q &amp;&amp; !(b instanceof a.w)) throw Error(&quot;templateEngine must inherit from ko.templateEngine&quot;); g = b }; a.Ia = function (b, c, f, h, s) {</span></div>
<div class="line"><a name="l00369"></a><span class="lineno">  369</span>&#160;<span class="stringliteral">                    f = f || {}; if ((f.templateEngine || g) == q) throw Error(&quot;Set a template engine before calling renderTemplate&quot;);</span></div>
<div class="line"><a name="l00370"></a><span class="lineno">  370</span>&#160;<span class="stringliteral">                    s = s || &quot;replaceChildren&quot;; if (h) { var l = d(h); return a.h(function () { var g = c &amp;&amp; c instanceof a.G ? c : new a.G(a.a.c(c)), r = &quot;function&quot; == typeof b ? b(g.$data, g) : b, g = e(h, s, r, g, f); &quot;replaceNode&quot; == s &amp;&amp; (h = g, l = d(h)) }, null, { ua: function () { return !l || !a.a.va(l) }, I: l &amp;&amp; &quot;replaceNode&quot; == s ? l.parentNode : l }) } return a.u.Ca(function (d) { a.Ia(b, c, f, d, &quot;replaceNode&quot;) })</span></div>
<div class="line"><a name="l00371"></a><span class="lineno">  371</span>&#160;<span class="stringliteral">                }; a.$b = function (b, d, f, g, h) {</span></div>
<div class="line"><a name="l00372"></a><span class="lineno">  372</span>&#160;<span class="stringliteral">                    function l(a, b) { c(b, r); f.afterRender &amp;&amp; f.afterRender(b, a) } function n(a, c) {</span></div>
<div class="line"><a name="l00373"></a><span class="lineno">  373</span>&#160;<span class="stringliteral">                        r = h.createChildContext(a, f.as, function (a) { a.$index = c }); var d = &quot;function&quot; ==</span></div>
<div class="line"><a name="l00374"></a><span class="lineno">  374</span>&#160;<span class="stringliteral">                        typeof b ? b(a, r) : b; return e(null, &quot;ignoreTargetNode&quot;, d, r, f)</span></div>
<div class="line"><a name="l00375"></a><span class="lineno">  375</span>&#160;<span class="stringliteral">                    } var r; return a.h(function () { var b = a.a.c(d) || []; &quot;undefined&quot; == typeof b.length &amp;&amp; (b = [b]); b = a.a.ga(b, function (b) { return f.includeDestroyed || b === q || null === b || !a.a.c(b._destroy) }); a.i.p(a.a.Ja, null, [g, b, n, f, l]) }, null, { I: g })</span></div>
<div class="line"><a name="l00376"></a><span class="lineno">  376</span>&#160;<span class="stringliteral">                }; var h = a.a.f.D(); a.d.template = {</span></div>
<div class="line"><a name="l00377"></a><span class="lineno">  377</span>&#160;<span class="stringliteral">                    init: function (b, c) { var d = a.a.c(c()); &quot;string&quot; == typeof d || d.name ? a.e.Z(b) : (d = a.e.childNodes(b), d = a.a.Vb(d), (new a.m.W(b)).nodes(d)); return { controlsDescendantBindings: !0 } }, update: function (b, c, d, e, g) {</span></div>
<div class="line"><a name="l00378"></a><span class="lineno">  378</span>&#160;<span class="stringliteral">                        c =</span></div>
<div class="line"><a name="l00379"></a><span class="lineno">  379</span>&#160;<span class="stringliteral">                        a.a.c(c()); d = {}; e = !0; var l, n = null; &quot;string&quot; != typeof c &amp;&amp; (d = c, c = a.a.c(d.name), &quot;if&quot; in d &amp;&amp; (e = a.a.c(d[&quot;if&quot;])), e &amp;&amp; &quot;ifnot&quot; in d &amp;&amp; (e = !a.a.c(d.ifnot)), l = a.a.c(d.data)); &quot;foreach&quot; in d ? n = a.$b(c || b, e &amp;&amp; d.foreach || [], d, b, g) : e ? (g = &quot;data&quot; in d ? g.createChildContext(l, d.as) : g, n = a.Ia(c || b, g, d, b)) : a.e.Z(b); g = n; (l = a.a.f.get(b, h)) &amp;&amp; &quot;function&quot; == typeof l.B &amp;&amp; l.B(); a.a.f.set(b, h, g &amp;&amp; g.aa() ? g : q)</span></div>
<div class="line"><a name="l00380"></a><span class="lineno">  380</span>&#160;<span class="stringliteral">                    }</span></div>
<div class="line"><a name="l00381"></a><span class="lineno">  381</span>&#160;<span class="stringliteral">                }; a.g.Y.template = function (b) { b = a.g.Ga(b); return 1 == b.length &amp;&amp; b[0].unknown || a.g.Sb(b, &quot;name&quot;) ? null : &quot;This template engine does not support anonymous templates nested within its templates&quot; };</span></div>
<div class="line"><a name="l00382"></a><span class="lineno">  382</span>&#160;<span class="stringliteral">                a.e.P.template = !0</span></div>
<div class="line"><a name="l00383"></a><span class="lineno">  383</span>&#160;<span class="stringliteral">            })(); a.b(&quot;setTemplateEngine&quot;, a.La); a.b(&quot;renderTemplate&quot;, a.Ia); a.a.ra = function () {</span></div>
<div class="line"><a name="l00384"></a><span class="lineno">  384</span>&#160;<span class="stringliteral">                function a(b, d, e, g, h) {</span></div>
<div class="line"><a name="l00385"></a><span class="lineno">  385</span>&#160;<span class="stringliteral">                    var k = Math.min, m = Math.max, f = [], p, q = b.length, l, n = d.length, r = n - q || 1, v = q + n + 1, t, u, w; for (p = 0; p &lt;= q; p++) for (u = t, f.push(t = []), w = k(n, p + r), l = m(0, p - 1) ; l &lt;= w; l++) t[l] = l ? p ? b[p - 1] === d[l - 1] ? u[l - 1] : k(u[l] || v, t[l - 1] || v) + 1 : l + 1 : p + 1; k = []; m = []; r = []; p = q; for (l = n; p || l;) n = f[p][l] - 1, l &amp;&amp; n === f[p][l - 1] ? m.push(k[k.length] = { status: e, value: d[--l], index: l }) : p &amp;&amp; n === f[p - 1][l] ? r.push(k[k.length] = {</span></div>
<div class="line"><a name="l00386"></a><span class="lineno">  386</span>&#160;<span class="stringliteral">                        status: g, value: b[--p],</span></div>
<div class="line"><a name="l00387"></a><span class="lineno">  387</span>&#160;<span class="stringliteral">                        index: p</span></div>
<div class="line"><a name="l00388"></a><span class="lineno">  388</span>&#160;<span class="stringliteral">                    }) : (--l, --p, h.sparse || k.push({ status: &quot;retained&quot;, value: d[l] })); if (m.length &amp;&amp; r.length) { b = 10 * q; var z; for (d = e = 0; (h.dontLimitMoves || d &lt; b) &amp;&amp; (z = m[e]) ; e++) { for (g = 0; f = r[g]; g++) if (z.value === f.value) { z.moved = f.index; f.moved = z.index; r.splice(g, 1); d = g = 0; break } d += g } } return k.reverse()</span></div>
<div class="line"><a name="l00389"></a><span class="lineno">  389</span>&#160;<span class="stringliteral">                } return function (c, d, e) { e = &quot;boolean&quot; === typeof e ? { dontLimitMoves: e } : e || {}; c = c || []; d = d || []; return c.length &lt;= d.length ? a(c, d, &quot;added&quot;, &quot;deleted&quot;, e) : a(d, c, &quot;deleted&quot;, &quot;added&quot;, e) }</span></div>
<div class="line"><a name="l00390"></a><span class="lineno">  390</span>&#160;<span class="stringliteral">            }(); a.b(&quot;utils.compareArrays&quot;, a.a.ra); (function () {</span></div>
<div class="line"><a name="l00391"></a><span class="lineno">  391</span>&#160;<span class="stringliteral">                function b(b,</span></div>
<div class="line"><a name="l00392"></a><span class="lineno">  392</span>&#160;<span class="stringliteral">                c, g, h, k) { var m = [], f = a.h(function () { var f = c(g, k, a.a.$(m, b)) || []; 0 &lt; m.length &amp;&amp; (a.a.nb(m, f), h &amp;&amp; a.i.p(h, null, [g, f, k])); m.splice(0, m.length); a.a.X(m, f) }, null, { I: b, ua: function () { return !a.a.Ra(m) } }); return { R: m, h: f.aa() ? f : q } } var c = a.a.f.D(); a.a.Ja = function (d, e, g, h, k) {</span></div>
<div class="line"><a name="l00393"></a><span class="lineno">  393</span>&#160;<span class="stringliteral">                    function m(b, c) { x = s[c]; t !== c &amp;&amp; (z[b] = x); x.za(t++); a.a.$(x.R, d); r.push(x); w.push(x) } function f(b, c) { if (b) for (var d = 0, e = c.length; d &lt; e; d++) c[d] &amp;&amp; a.a.n(c[d].R, function (a) { b(a, d, c[d].fa) }) } e = e || []; h = h || {}; var p = a.a.f.get(d, c) === q, s = a.a.f.get(d, c) || [],</span></div>
<div class="line"><a name="l00394"></a><span class="lineno">  394</span>&#160;<span class="stringliteral">                    l = a.a.ha(s, function (a) { return a.fa }), n = a.a.ra(l, e, h.dontLimitMoves), r = [], v = 0, t = 0, u = [], w = []; e = []; for (var z = [], l = [], x, A = 0, y, B; y = n[A]; A++) switch (B = y.moved, y.status) { case &quot;deleted&quot;: B === q &amp;&amp; (x = s[v], x.h &amp;&amp; x.h.B(), u.push.apply(u, a.a.$(x.R, d)), h.beforeRemove &amp;&amp; (e[A] = x, w.push(x))); v++; break; case &quot;retained&quot;: m(A, v++); break; case &quot;added&quot;: B !== q ? m(A, B) : (x = { fa: y.value, za: a.q(t++) }, r.push(x), w.push(x), p || (l[A] = x)) } f(h.beforeMove, z); a.a.n(u, h.beforeRemove ? a.L : a.removeNode); for (var A = 0, p = a.e.firstChild(d), C; x = w[A]; A++) {</span></div>
<div class="line"><a name="l00395"></a><span class="lineno">  395</span>&#160;<span class="stringliteral">                        x.R ||</span></div>
<div class="line"><a name="l00396"></a><span class="lineno">  396</span>&#160;<span class="stringliteral">                        a.a.extend(x, b(d, g, x.fa, k, x.za)); for (v = 0; n = x.R[v]; p = n.nextSibling, C = n, v++) n !== p &amp;&amp; a.e.eb(d, n, C); !x.Ob &amp;&amp; k &amp;&amp; (k(x.fa, x.R, x.za), x.Ob = !0)</span></div>
<div class="line"><a name="l00397"></a><span class="lineno">  397</span>&#160;<span class="stringliteral">                    } f(h.beforeRemove, e); f(h.afterMove, z); f(h.afterAdd, l); a.a.f.set(d, c, r)</span></div>
<div class="line"><a name="l00398"></a><span class="lineno">  398</span>&#160;<span class="stringliteral">                }</span></div>
<div class="line"><a name="l00399"></a><span class="lineno">  399</span>&#160;<span class="stringliteral">            })(); a.b(&quot;utils.setDomNodeChildrenFromArrayMapping&quot;, a.a.Ja); a.J = function () { this.allowTemplateRewriting = !1 }; a.J.prototype = new a.w; a.J.prototype.renderTemplateSource = function (b) { var c = (9 &gt; a.a.ja ? 0 : b.nodes) ? b.nodes() : null; if (c) return a.a.Q(c.cloneNode(!0).childNodes); b = b.text(); return a.a.Fa(b) }; a.J.Aa =</span></div>
<div class="line"><a name="l00400"></a><span class="lineno">  400</span>&#160;<span class="stringliteral">            new a.J; a.La(a.J.Aa); a.b(&quot;nativeTemplateEngine&quot;, a.J); (function () {</span></div>
<div class="line"><a name="l00401"></a><span class="lineno">  401</span>&#160;<span class="stringliteral">                a.Ba = function () {</span></div>
<div class="line"><a name="l00402"></a><span class="lineno">  402</span>&#160;<span class="stringliteral">                    var a = this.Rb = function () { if (&quot;undefined&quot; == typeof u || !u.tmpl) return 0; try { if (0 &lt;= u.tmpl.tag.tmpl.open.toString().indexOf(&quot;__&quot;)) return 2 } catch (a) { } return 1 }(); this.renderTemplateSource = function (b, e, g) {</span></div>
<div class="line"><a name="l00403"></a><span class="lineno">  403</span>&#160;<span class="stringliteral">                        g = g || {}; if (2 &gt; a) throw Error(&quot;Your version of jQuery.tmpl is too old. Please upgrade to jQuery.tmpl 1.0.0pre or later.&quot;); var h = b.data(&quot;precompiled&quot;); h || (h = b.text() || &quot;&quot;, h = u.template(null, &quot;{{ko_with $item.koBindingContext}}&quot; + h +</span></div>
<div class="line"><a name="l00404"></a><span class="lineno">  404</span>&#160;<span class="stringliteral">                        &quot;{{/ko_with}}&quot;), b.data(&quot;precompiled&quot;, h)); b = [e.$data]; e = u.extend({ koBindingContext: e }, g.templateOptions); e = u.tmpl(h, b, e); e.appendTo(w.createElement(&quot;div&quot;)); u.fragments = {}; return e</span></div>
<div class="line"><a name="l00405"></a><span class="lineno">  405</span>&#160;<span class="stringliteral">                    }; this.createJavaScriptEvaluatorBlock = function (a) { return &quot;{{ko_code ((function() { return &quot; + a + &quot; })()) }}&quot; }; this.addTemplate = function (a, b) { w.write(&quot;&lt;script type=&#39;</span>text/html<span class="stringliteral">&#39; id=&#39;</span><span class="stringliteral">&quot; + a + &quot;</span><span class="stringliteral">&#39;&gt;&quot; + b + &quot;\x3c/script&gt;&quot;) }; 0 &lt; a &amp;&amp; (u.tmpl.tag.ko_code = { open: &quot;__.push($1 || &#39;</span><span class="stringliteral">&#39;);&quot; }, u.tmpl.tag.ko_with = { open: &quot;with($1) {&quot;, close: &quot;} &quot; })</span></div>
<div class="line"><a name="l00406"></a><span class="lineno">  406</span>&#160;<span class="stringliteral">                }; a.Ba.prototype =</span></div>
<div class="line"><a name="l00407"></a><span class="lineno">  407</span>&#160;<span class="stringliteral">                new a.w; var b = new a.Ba; 0 &lt; b.Rb &amp;&amp; a.La(b); a.b(&quot;jqueryTmplTemplateEngine&quot;, a.Ba)</span></div>
<div class="line"><a name="l00408"></a><span class="lineno">  408</span>&#160;<span class="stringliteral">            })()</span></div>
<div class="line"><a name="l00409"></a><span class="lineno">  409</span>&#160;<span class="stringliteral">        })</span></div>
<div class="line"><a name="l00410"></a><span class="lineno">  410</span>&#160;<span class="stringliteral">    })();</span></div>
<div class="line"><a name="l00411"></a><span class="lineno">  411</span>&#160;<span class="stringliteral">})();</span></div>
</div><!-- fragment --></div><!-- contents -->
<!-- start footer part -->
<hr class="footer"/><address class="footer"><small>
Erzeugt am Don Dez 12 2013 10:15:57 für Homework Hub von &#160;<a href="http://www.doxygen.org/index.html">
<img class="footer" src="doxygen.png" alt="doxygen"/>
</a> 1.8.5
</small></address>
</body>
</html>
